Fix #773: Add bf_vs_ilp tests for all ILP reduction rules (#778)

* Fix #773: Add bf_vs_ilp tests for all 85 ILP reduction rules

Every *_ilp.rs test file now has a test_*_to_ilp_bf_vs_ilp function
that solves the source problem with BruteForce, solves the ILP
reduction with ILPSolver, extracts the solution back, and asserts
the two objective values match.

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

* Simplify: extract assert_bf_vs_ilp helper, remove boilerplate

Extract shared `assert_bf_vs_ilp` helper into `test_helpers.rs` and
refactor 44 bf_vs_ilp tests to use it, eliminating ~216 lines of
duplicated solve-compare boilerplate. Clean up unused Solver imports.

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

* Remove duplicate BF-vs-ILP checks from closed_loop tests

The bf_vs_ilp tests now own the BF-vs-ILP value comparison.
Simplify MVC/MIS closed_loop tests to only assert structural
properties (ilp_size, is_valid). Delete OLA optimization test
that was fully subsumed by bf_vs_ilp.

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

---------

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

Author: isPANN

src/rules/test_helpers.rs

@@ -193,6 +193,23 @@ pub(crate) fn assert_satisfaction_round_trip_from_satisfaction_target<R>(
     );
 }
 
+#[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,
+{
+    use crate::solvers::{ILPSolver, Solver};
+    let bf_value = BruteForce::new().solve(source);
+    let ilp_solution = ILPSolver::new()
+        .solve_dyn(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,

src/unit_tests/rules/acyclicpartition_ilp.rs

@@ -78,3 +78,10 @@ fn test_infeasible_instance() {
     let solver = ILPSolver::new();
     assert!(solver.solve(ilp).is_none());
 }
+
+#[test]
+fn test_acyclicpartition_to_ilp_bf_vs_ilp() {
+    let source = small_instance();
+    let reduction: ReductionAcyclicPartitionToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+}

src/unit_tests/rules/balancedcompletebipartitesubgraph_ilp.rs

@@ -58,3 +58,10 @@ fn test_extract_solution_identity() {
     assert_eq!(extracted, vec![1, 1, 0, 1, 1, 0]);
     assert!(source.evaluate(&extracted).0);
 }
+
+#[test]
+fn test_balancedcompletebipartitesubgraph_to_ilp_bf_vs_ilp() {
+    let source = small_instance();
+    let reduction: ReductionBCBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+}

src/unit_tests/rules/bicliquecover_ilp.rs

@@ -61,3 +61,10 @@ fn test_single_edge() {
         "single edge biclique cover",
     );
 }
+
+#[test]
+fn test_bicliquecover_to_ilp_bf_vs_ilp() {
+    let source = small_instance();
+    let reduction: ReductionBicliqueCoverToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+}

src/unit_tests/rules/biconnectivityaugmentation_ilp.rs

@@ -77,3 +77,10 @@ fn test_already_biconnected() {
     let extracted = reduction.extract_solution(&ilp_sol);
     assert!(source.evaluate(&extracted).0);
 }
+
+#[test]
+fn test_biconnectivityaugmentation_to_ilp_bf_vs_ilp() {
+    let source = small_instance();
+    let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+}

src/unit_tests/rules/binpacking_ilp.rs

@@ -141,3 +141,10 @@ fn test_solve_reduced() {
     assert!(problem.evaluate(&solution).is_valid());
     assert_eq!(problem.evaluate(&solution), 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);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
+}

src/unit_tests/rules/bottlenecktravelingsalesman_ilp.rs

@@ -96,3 +96,10 @@ fn test_no_hamiltonian_cycle_infeasible() {
         "Path graph should have no Hamiltonian cycle"
     );
 }
+
+#[test]
+fn test_bottlenecktravelingsalesman_to_ilp_bf_vs_ilp() {
+    let problem = k4_btsp();
+    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
+}

src/unit_tests/rules/boundedcomponentspanningforest_ilp.rs

@@ -83,3 +83,10 @@ fn test_infeasible_instance() {
     let solver = ILPSolver::new();
     assert!(solver.solve(ilp).is_none());
 }
+
+#[test]
+fn test_boundedcomponentspanningforest_to_ilp_bf_vs_ilp() {
+    let source = small_instance();
+    let reduction: ReductionBCSFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+}

src/unit_tests/rules/capacityassignment_ilp.rs

@@ -101,3 +101,15 @@ fn test_capacityassignment_to_ilp_trivial() {
     let extracted = reduction.extract_solution(&ilp_solution);
     assert!(problem.evaluate(&extracted).0.is_some());
 }
+
+#[test]
+fn test_capacityassignment_to_ilp_bf_vs_ilp() {
+    let problem = CapacityAssignment::new(
+        vec![1, 2, 3],
+        vec![vec![1, 3, 6], vec![2, 4, 7], vec![1, 2, 5]],
+        vec![vec![8, 4, 1], vec![7, 3, 1], vec![6, 3, 1]],
+        12,
+    );
+    let reduction: ReductionCAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
+}

src/unit_tests/rules/coloring_ilp.rs

@@ -271,3 +271,10 @@ fn test_single_edge() {
     assert!(problem.evaluate(&extracted));
     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);
+    crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
+}