Add rule: ExactCoverBy3Sets -> BoundedDiameterSpanningTree (#913)

isPANN · claude · isPANN · commit a8ee2fa67149 · 2026-05-27T01:21:12.000+08:00
Co-Authored-By: Claude Opus 4.7 &lt;noreply@anthropic.com&gt;
diff --git a/docs/paper/reductions.typ b/docs/paper/reductions.typ
@@ -18608,6 +18608,54 @@ The following table shows concrete variable overhead for example instances, take
   _Solution extraction._ The X3C configuration equals the Subset Product configuration: select subset $j$ iff $x_j = 1$.
 ]
 
+// ExactCoverBy3Sets → BoundedDiameterSpanningTree (#913)
+#let x3c_bdst = load-example("ExactCoverBy3Sets", "BoundedDiameterSpanningTree")
+#let x3c_bdst_sol = x3c_bdst.solutions.at(0)
+#let x3c_bdst_nv = graph-num-vertices(x3c_bdst.target.instance)
+#let x3c_bdst_ne = graph-num-edges(x3c_bdst.target.instance)
+#reduction-rule("ExactCoverBy3Sets", "BoundedDiameterSpanningTree",
+  example: true,
+  example-caption: [$|U| = #x3c_bdst.source.instance.universe_size$, $|cal(C)| = #x3c_bdst.source.instance.subsets.len()$ subsets; target $D = #x3c_bdst.target.instance.diameter_bound$, $B = #x3c_bdst.target.instance.weight_bound$],
+  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 solve bundle.json",
+      "pred evaluate x3c.json --config " + x3c_bdst_sol.source_config.map(str).join(","),
+    )
+
+    #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 [.]
+    ]
+
+    *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.
+
+    *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.
+][
+  _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
+  $
+    (r, v_1) " and " (v_1, v_2) " of weight " 1, quad (r, s_i) " of weight " 2 " for every " i,
+  $
+  $
+    (s_i, e_j) " of weight " 1 " whenever " j in C_i, quad (s_i, s_(i')) " of weight " 1 " for all " 0 <= i < i' < m.
+  $
+  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$.
+
+  ($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.
+
+  _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)
 #let ss_iem = load-example("SubsetSum", "IntegerExpressionMembership")
 #let ss_iem_sol = ss_iem.solutions.at(0)
diff --git a/src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs b/src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
@@ -0,0 +1,184 @@
+//! Reduction from ExactCoverBy3Sets to BoundedDiameterSpanningTree.
+//!
+//! Given an X3C instance with universe X (|X| = 3q) and collection
+//! C = [S_0, ..., S_{m-1}] of 3-element subsets of X, build a weighted graph
+//! and parameters (B, D) so that the BDST instance is feasible iff the source
+//! has an exact cover.
+//!
+//! Construction (Garey & Johnson, ND4):
+//!
+//! * Vertex set V = {r, v_1, v_2} ∪ {s_0, ..., s_{m-1}} ∪ {e_0, ..., e_{3q-1}}.
+//!   Indices: r = 0, v_1 = 1, v_2 = 2, s_i = 3 + i, e_j = 3 + m + j.
+//! * Edges (all weights ∈ {1, 2}):
+//!     - Forced-center path: (r, v_1) weight 1, (v_1, v_2) weight 1.
+//!     - Root-to-set: (r, s_i) weight 2 for every i ∈ [0, m).
+//!     - Set-to-element: (s_i, e_j) weight 1 whenever j ∈ S_i.
+//!     - Set clique: (s_i, s_j) weight 1 for all 0 ≤ i < j < m.
+//! * Diameter bound D = 4.
+//! * Weight bound B = 4q + m + 2.
+//!
+//! Forward direction: an exact cover C' = {S_{i_1}, ..., S_{i_q}} yields a
+//! spanning tree of total weight 2q + (m - q) + 3q + 2 = 4q + m + 2 = B and
+//! every vertex within distance 2 of r, so the diameter is ≤ 4.
+//!
+//! Backward direction: any feasible spanning tree must keep every vertex
+//! within distance 2 of r (otherwise dist to v_2 exceeds 4). Element vertices
+//! only attach through set vertices, so each e_j sits at depth 2 below some
+//! s_i that is directly attached to r. Budget counting then forces the number
+//! of root-to-set edges to be exactly q, and pigeonhole on the 3q element
+//! attachments forces the q chosen sets to be pairwise disjoint -- an exact
+//! cover.
+//!
+//! The solution extractor reads the binary indicator of each root-to-set edge.
+
+use crate::models::graph::BoundedDiameterSpanningTree;
+use crate::models::set::ExactCoverBy3Sets;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::topology::SimpleGraph;
+
+/// Result of reducing ExactCoverBy3Sets to BoundedDiameterSpanningTree.
+#[derive(Debug, Clone)]
+pub struct ReductionX3CToBoundedDiameterSpanningTree {
+    target: BoundedDiameterSpanningTree<SimpleGraph, i32>,
+    source_num_subsets: usize,
+}
+
+impl ReductionResult for ReductionX3CToBoundedDiameterSpanningTree {
+    type Source = ExactCoverBy3Sets;
+    type Target = BoundedDiameterSpanningTree<SimpleGraph, i32>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    /// Extract the chosen source subsets from the spanning-tree configuration.
+    ///
+    /// The construction places the m root-to-set edges (r, s_i) at edge indices
+    /// 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()
+    }
+}
+
+#[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 {
+    type Result = ReductionX3CToBoundedDiameterSpanningTree;
+
+    fn reduce_to(&self) -> Self::Result {
+        let universe_size = self.universe_size();
+        let m = self.num_subsets();
+        let q = universe_size / 3;
+
+        // 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();
+
+        // Forced-center path edges (indices 0 and 1).
+        edges.push((0, 1)); // (r, v_1)
+        weights.push(1);
+        edges.push((1, 2)); // (v_1, v_2)
+        weights.push(1);
+
+        // Root-to-set edges (indices 2..2+m). The extractor relies on this layout.
+        for i in 0..m {
+            edges.push((0, s_index(i)));
+            weights.push(2);
+        }
+
+        // Set-to-element edges. Subsets are already sorted in `ExactCoverBy3Sets::new`.
+        for (i, subset) in self.subsets().iter().enumerate() {
+            for &j in subset {
+                edges.push((s_index(i), e_index(j)));
+                weights.push(1);
+            }
+        }
+
+        // Set clique edges.
+        for i in 0..m {
+            for j in (i + 1)..m {
+                edges.push((s_index(i), s_index(j)));
+                weights.push(1);
+            }
+        }
+
+        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 {
+            target,
+            source_num_subsets: m,
+        }
+    }
+}
+
+#[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: "exactcoverby3sets_to_boundeddiameterspanningtree",
+        build: || {
+            // q = 2, m = 2: X = {0..5}, C = [{0,1,2}, {3,4,5}].
+            // Exact cover: both subsets. Target has 11 vertices and 11 edges,
+            // so brute-force solving stays well under the 5s test budget.
+            let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]]);
+
+            // Source: select both subsets.
+            let source_config = vec![1, 1];
+
+            // 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,
+            //   (s0,e0)=idx 4, (s0,e1)=idx 5, (s0,e2)=idx 6,
+            //   (s1,e3)=idx 7, (s1,e4)=idx 8, (s1,e5)=idx 9,
+            //   (s0,s1)=idx 10 (unused clique edge).
+            //
+            // Layout (from `reduce_to`):
+            //   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];
+
+            crate::example_db::specs::rule_example_with_witness::<
+                _,
+                BoundedDiameterSpanningTree<SimpleGraph, i32>,
+            >(
+                source,
+                SolutionPair {
+                    source_config,
+                    target_config,
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs"]
+mod tests;
diff --git a/src/rules/mod.rs b/src/rules/mod.rs
@@ -18,6 +18,7 @@ pub(crate) mod decisionminimumdominatingset_minimumsummulticenter;
 pub(crate) mod decisionminimumdominatingset_minmaxmulticenter;
 pub(crate) mod decisionminimumvertexcover_hamiltoniancircuit;
 pub(crate) mod exactcoverby3sets_algebraicequationsovergf2;
+pub(crate) mod exactcoverby3sets_boundeddiameterspanningtree;
 pub(crate) mod exactcoverby3sets_maximumsetpacking;
 pub(crate) mod exactcoverby3sets_minimumaxiomset;
 pub(crate) mod exactcoverby3sets_minimumfaultdetectiontestset;
@@ -415,6 +416,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(closestvectorproblem_qubo::canonical_rule_example_specs());
     specs.extend(coloring_qubo::canonical_rule_example_specs());
     specs.extend(exactcoverby3sets_algebraicequationsovergf2::canonical_rule_example_specs());
+    specs.extend(exactcoverby3sets_boundeddiameterspanningtree::canonical_rule_example_specs());
     specs.extend(exactcoverby3sets_minimumfaultdetectiontestset::canonical_rule_example_specs());
     specs.extend(exactcoverby3sets_minimumaxiomset::canonical_rule_example_specs());
     specs.extend(exactcoverby3sets_subsetproduct::canonical_rule_example_specs());
diff --git a/src/unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs b/src/unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
@@ -0,0 +1,106 @@
+use super::*;
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
+use crate::solvers::BruteForce;
+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}].
+/// Both subsets together form the unique exact cover.
+fn yes_instance_simple() -> ExactCoverBy3Sets {
+    ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]])
+}
+
+/// q = 2, m = 2 but the two subsets overlap on element 0,
+/// so no exact cover exists.
+fn no_instance_simple() -> ExactCoverBy3Sets {
+    ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [0, 3, 4]])
+}
+
+#[test]
+fn test_exactcoverby3sets_to_boundeddiameterspanningtree_closed_loop() {
+    let source = yes_instance_simple();
+    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i32>>::reduce_to(&source);
+
+    assert_satisfaction_round_trip_from_satisfaction_target(
+        &source,
+        &reduction,
+        "ExactCoverBy3Sets -> 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 target = reduction.target_problem();
+
+    let m = source.num_subsets();
+    let q = source.universe_size() / 3;
+    // 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.
+    let expected_edges = 2 + m + 3 * m + m * (m - 1) / 2;
+    assert_eq!(target.num_edges(), expected_edges);
+
+    // 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;
+    assert_eq!(*target.weight_bound(), expected_weight_bound);
+
+    // Verify the first two edges are the forced-center path with weight 1.
+    let edges = target.graph().edges();
+    let weights = target.edge_weights();
+    assert_eq!(edges[0], (0, 1));
+    assert_eq!(weights[0], 1);
+    assert_eq!(edges[1], (1, 2));
+    assert_eq!(weights[1], 1);
+
+    // Root-to-set edges follow, at indices 2..2+m, weight 2.
+    for i in 0..m {
+        assert_eq!(edges[2 + i], (0, 3 + i));
+        assert_eq!(weights[2 + i], 2);
+    }
+}
+
+#[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]);
+}
+
+#[test]
+fn test_exactcoverby3sets_to_boundeddiameterspanningtree_no_instance() {
+    let source = no_instance_simple();
+    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i32>>::reduce_to(&source);
+    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);
+    }
+}
