Fix ILP i32->bool cast overhead: use size-field name num_vars, not getter alias (#1080)

Root cause of the `pred path MinimumFeedbackVertexSet ILP` bug (asymptotic `num_vars`
composed to `O(num_variables)` instead of `O(num_vertices)`): the `ILP<i32> → ILP<bool>`
binary-encoding cast declared its overhead as `num_vars = "31 * num_variables"`. ILP's
size field is named `num_vars`; `num_variables()` is only a getter *alias* for it. The
`#[reduction]` macro validates overhead variables against getter *methods*, so the alias
compiled, and both instance-mode sizing (`evaluate_output_size` calls the getter) and
raw-overhead Big-O rendering resolve it — the mistake was invisible there.

But asymptotic growth composition (`GrowthLabel::extend`) threads size-field *names*: the
label key at the ILP node is `num_vars`, so the variable `num_variables` was unmapped and
leaked through unchanged as `num_vars = O(num_variables)`. The path's arrow display had
also masked this by collapsing the hidden `ILP/i32 → ILP/bool` cast step.

Fix: `31 * num_variables` → `31 * num_vars` (semantically identical — 31 bits per integer
variable — and numerically unchanged, since both getters return `num_vars`).

Effects: `MFVS → ILP` now composes `num_vars = O(num_vertices)`. `MVC → ILP` drops from 3
to 2 front paths — the corrected feedback-vertex-set route
(`num_constraints = O(num_edges + num_vertices), num_vars = O(num_vertices)`) is now
correctly Pareto-dominated by the direct route and pruned.

Test: `test_asymptotic_front_uses_only_source_variables_mfvs_ilp` pins
`num_vars = O(num_vertices)` and asserts every composed field's growth references only
MinimumFeedbackVertexSet's own size variables — a general "source-variables-only"
invariant on the front label.

Note: this is one instance of a getter-alias-vs-field-name mismatch. A separate, broader
class of leaks remains in other reductions (e.g. `ClosestVectorProblem`'s `num_encoding_bits`
and `CircuitSAT`'s `tseitin_num_vars`/`tseitin_num_clauses`, which surface in KSat→QUBO);
those are genuine field-name inconsistencies between a node's incoming and outgoing
reductions, outside the growth-composition logic, and are left for separate scoping.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EgxSbn5gwizTBkC22eyWXR

Author: isPANN

src/rules/ilp_i32_ilp_bool.rs

@@ -264,7 +264,7 @@ impl ReductionResult for ReductionIntILPToBinaryILP {
 }
 
 #[reduction(overhead = {
-    num_vars = "31 * num_variables",
+    num_vars = "31 * num_vars",
     num_constraints = "num_constraints",
 })]
 impl ReduceTo<ILP<bool>> for ILP<i32> {

src/unit_tests/rules/pareto.rs

@@ -714,3 +714,74 @@ fn test_asymptotic_front_dedups_by_growth_vector() {
         front.len()
     );
 }
+
+/// A composed front label must express every size field's growth purely in the
+/// **source problem's** own size variables — never in a downstream getter alias or an
+/// intermediate node's field name.
+///
+/// Regression for the `MinimumFeedbackVertexSet → ILP` bug: the `ILP<i32> → ILP<bool>`
+/// binary-encoding cast declared its overhead as `num_vars = "31 * num_variables"`,
+/// referencing the getter *alias* `num_variables()` instead of ILP's size-field *name*
+/// `num_vars`. Instance mode and raw-overhead rendering both resolve the getter, so the
+/// mistake was invisible there — but growth composition threads field *names*, so the
+/// alias was unmapped and leaked through as `num_vars = O(num_variables)` instead of
+/// the correct `O(num_vertices)`.
+#[test]
+fn test_asymptotic_front_uses_only_source_variables_mfvs_ilp() {
+    let graph = ReductionGraph::new();
+    let src_v = graph
+        .default_variant_for("MinimumFeedbackVertexSet")
+        .or_else(|| {
+            graph
+                .variants_for("MinimumFeedbackVertexSet")
+                .into_iter()
+                .next()
+        })
+        .expect("MinimumFeedbackVertexSet registered");
+    let dst_v = graph
+        .default_variant_for("ILP")
+        .or_else(|| graph.variants_for("ILP").into_iter().next())
+        .expect("ILP registered");
+
+    let front = graph.asymptotic_front(
+        "MinimumFeedbackVertexSet",
+        &src_v,
+        "ILP",
+        &dst_v,
+        ReductionMode::Witness,
+    );
+
+    // The direct route (MFVS → ILP/i32 → ILP/bool; the ILP variants collapse in the
+    // deduplicated node-name view) is the one exercised by the fixed cast.
+    let (_, label) = front
+        .iter()
+        .find(|(p, _)| p.type_names() == ["MinimumFeedbackVertexSet", "ILP"])
+        .expect("direct MinimumFeedbackVertexSet -> ILP path");
+
+    // The size fields of MinimumFeedbackVertexSet — the only variables any composed
+    // growth is allowed to mention.
+    let allowed = ["num_arcs", "num_vertices"];
+    for (field, growth) in label.fields() {
+        let expr = growth
+            .to_expr()
+            .unwrap_or_else(|| panic!("field {field} should have a bounded growth"));
+        for var in expr.variables() {
+            assert!(
+                allowed.contains(&var),
+                "field `{field}` growth O({expr}) references `{var}`, which is not a \
+                 MinimumFeedbackVertexSet source variable {allowed:?}",
+            );
+        }
+    }
+
+    // The previously-buggy field, pinned to the correct source-variable Big-O.
+    let num_vars = label
+        .fields()
+        .get("num_vars")
+        .expect("ILP has a num_vars size field");
+    assert_eq!(
+        num_vars.to_expr().unwrap().to_string(),
+        "num_vertices",
+        "ILP num_vars must compose to O(num_vertices), not the getter alias num_variables"
+    );
+}