fix: model_specs_are_optimal stuck on DecisionMVC→HC→QA→ILP chain

The new DecisionMVC→HamiltonianCircuit reduction created a path
DecisionMVC → HC(50 verts) → QA(2500 vars) → ILP that HiGHS can't
solve in reasonable time.

Fix: try brute force first for small instances (≤2^20 configs) before
falling back to ILP via reduction. DecisionMVC with 4 vertices has
only 16 configs — instant via brute force.

Also add CLAUDE.md note: overhead expressions describe scaling, not
exact sizes — read reduce_to() code for actual sizes.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GiggleLiu

.claude/CLAUDE.md

@@ -162,6 +162,7 @@ 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
 - `VariantEntry` has both a complexity string and compiled `complexity_eval_fn` — same pattern

src/unit_tests/example_db.rs

@@ -517,20 +517,20 @@ fn model_specs_are_optimal() {
     for spec in specs {
         let name = spec.instance.problem_name();
         let variant = spec.instance.variant_map();
-        // Try ILP (direct or via reduction), fall back to brute force for small instances
-        let best_config = ilp_solver
-            .solve_via_reduction(name, &variant, spec.instance.as_any())
-            .or_else(|| {
-                // Only brute-force if search space is small (≤ 2^20 configs)
-                let dims = spec.instance.dims_dyn();
-                let log_space: f64 = dims.iter().map(|&d| (d as f64).log2()).sum();
-                if log_space > 20.0 {
-                    return None;
-                }
-                let entry = find_variant_entry(name, &variant)?;
-                let (config, _) = (entry.solve_witness_fn)(spec.instance.as_any())?;
-                Some(config)
-            });
+        // 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())
+                })
+        } else {
+            ilp_solver
+                .solve_via_reduction(name, &variant, spec.instance.as_any())
+        };
 
         if let Some(best_config) = best_config {
             let best_value = spec.instance.evaluate_json(&best_config);