Fix nits: ExactCoverBy3Sets -> BoundedDiameterSpanningTree (#913)

- Add `q()` helper on ExactCoverBy3Sets and use it in the rule and tests
  instead of recomputing `universe_size / 3`.
- Add a `debug_assert!` in `reduce_to` confirming that root-to-set edges
  occupy indices 2..2+m, so a future reordering will surface a failure
  in `extract_solution`.
- Simplify the `no_instance` test: drop the duplicate assertion and the
  `unwrap_or_default` fallback; assert directly that `find_witness` is
  `None` and that the brute-force aggregate is `Or(false)` for an
  infeasible Or-valued target.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: isPANN

src/models/set/exact_cover_by_3_sets.rs

@@ -109,6 +109,14 @@ impl ExactCoverBy3Sets {
         self.subsets.len()
     }
 
+    /// Get q = universe_size / 3, the number of subsets in any exact cover.
+    ///
+    /// `ExactCoverBy3Sets::new` enforces `universe_size % 3 == 0`, so this
+    /// division is always exact.
+    pub fn q(&self) -> usize {
+        self.universe_size / 3
+    }
+
     /// Get the number of sets in the collection.
     pub fn num_sets(&self) -> usize {
         self.num_subsets()

src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs

@@ -87,7 +87,7 @@ impl ReduceTo<BoundedDiameterSpanningTree<SimpleGraph, i32>> for ExactCoverBy3Se
     fn reduce_to(&self) -> Self::Result {
         let universe_size = self.universe_size();
         let m = self.num_subsets();
-        let q = universe_size / 3;
+        let q = self.q();
 
         // Vertex indexing matches the docstring.
         let s_index = |i: usize| 3 + i;
@@ -108,6 +108,13 @@ impl ReduceTo<BoundedDiameterSpanningTree<SimpleGraph, i32>> for ExactCoverBy3Se
             edges.push((0, s_index(i)));
             weights.push(2);
         }
+        // Invariant: extract_solution reads edges[2..2 + m] to recover the
+        // selected subsets. If this loop is ever reordered or moved, the
+        // extractor must be updated to match.
+        debug_assert!(
+            (0..m).all(|i| edges[2 + i] == (0, s_index(i))),
+            "root-to-set edges must occupy indices 2..2+m for extract_solution to work"
+        );
 
         // Set-to-element edges. Subsets are already sorted in `ExactCoverBy3Sets::new`.
         for (i, subset) in self.subsets().iter().enumerate() {

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;
+use crate::solvers::{BruteForce, Solver};
 use crate::topology::Graph;
-use crate::traits::Problem;
 use crate::types::Or;
 
 /// q = 2, m = 2: X = {0..5} with C = [{0,1,2}, {3,4,5}].
@@ -36,7 +35,7 @@ fn test_exactcoverby3sets_to_boundeddiameterspanningtree_structure() {
     let target = reduction.target_problem();
 
     let m = source.num_subsets();
-    let q = source.universe_size() / 3;
+    let q = source.q();
     // n = 3 + m + 3q
     assert_eq!(target.num_vertices(), 3 + m + source.universe_size());
     // Expected edge count: 2 forced + m root-to-set + 3m set-to-element + m(m-1)/2 clique.
@@ -91,16 +90,11 @@ fn test_exactcoverby3sets_to_boundeddiameterspanningtree_no_instance() {
     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.
-    let witness = BruteForce::new().find_witness(target);
-    assert_eq!(
-        target.evaluate(&witness.clone().unwrap_or_default()),
-        Or(false)
-    );
-    // BruteForce::find_witness returns the lexicographically-first optimal
-    // assignment; for an Or-valued infeasible target, even that witness
-    // evaluates to false.
-    if let Some(w) = witness {
-        assert!(!target.evaluate(&w).0);
-    }
+    // bound B = 4q + m + 2 = 12 and diameter bound D = 4. For an Or-valued
+    // problem with no satisfying configuration, BruteForce::find_witness
+    // 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));
 }