feat: add Clustering→ILP and MinimumFaultDetectionTestSet→ILP reductions

GiggleLiu · claude · GiggleLiu · commit ac6ff0ac235c · 2026-04-10T17:07:40.000+08:00
Clustering→ILP: binary assignment variables x[i,c], exact-one-cluster
constraints per element, conflict constraints for violated distance pairs.
Feasibility formulation (minimize 0). O(n·K) variables, O(n + n²·K) constraints.

MinimumFaultDetectionTestSet→ILP: binary selection variables per input-output
pair, covering constraints requiring each internal vertex appears in at least
one selected pair's coverage set. Minimize total selected pairs.
O(|I|·|O|) variables, O(internal vertices) constraints.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/docs/paper/reductions.typ b/docs/paper/reductions.typ
@@ -15161,6 +15161,50 @@ The following table shows concrete variable overhead for example instances, take
   _Solution extraction._ Read the cluster label of each source vertex as its color label.
 ]
 
+#let clustering_ilp = load-example("Clustering", "ILP")
+#let clustering_ilp_sol = clustering_ilp.solutions.at(0)
+#reduction-rule("Clustering", "ILP",
+  example: true,
+  example-caption: [4 elements, $K = 2$, $B = 1$ $arrow.r$ ILP with #clustering_ilp.target.instance.num_vars variables and #clustering_ilp.target.instance.constraints.len() constraints],
+  extra: [
+    #pred-commands(
+      "pred create --example " + problem-spec(clustering_ilp.source) + " -o clustering.json",
+      "pred reduce clustering.json --to " + target-spec(clustering_ilp) + " -o bundle.json",
+      "pred solve bundle.json",
+      "pred evaluate clustering.json --config " + clustering_ilp_sol.source_config.map(str).join(","),
+    )
+
+    #{
+      let n = clustering_ilp.source.instance.distances.len()
+      let k = clustering_ilp.source.instance.num_clusters
+      let b = clustering_ilp.source.instance.diameter_bound
+      let distances = clustering_ilp.source.instance.distances
+      let source-config = clustering_ilp_sol.source_config
+      [
+        *Step 1 -- Source instance.* The canonical source has $n = #n$ elements, cluster bound $K = #k$, and diameter bound $B = #b$. Its distance rows are #distances.map(row => "(" + row.map(str).join(", ") + ")").join("; "), so the only pairs above the bound are $(0, 2)$, $(0, 3)$, $(1, 2)$, and $(1, 3)$.
+
+        *Step 2 -- Build the ILP.* Introduce one binary variable $x_(i,c)$ for each element-cluster pair, giving $n K = #(n * k)$ variables. The $n = #n$ assignment equalities $sum_c x_(i,c) = 1$ force every element into exactly one cluster, and the four violating pairs contribute $4 dot K = #(4 * k)$ conflict inequalities. The stored target therefore has #clustering_ilp.target.instance.num_vars variables and #clustering_ilp.target.instance.constraints.len() constraints.
+
+        *Step 3 -- Verify the canonical witness.* The stored ILP vector is $(#clustering_ilp_sol.target_config.map(str).join(", "))$. Reading each block of $K = #k$ variables yields the clustering $(#source-config.map(str).join(", "))$, so cluster 0 contains elements ${#source-config.enumerate().filter(((i, c)) => c == 0).map(((i, c)) => str(i)).join(", ")}$ and cluster 1 contains elements ${#source-config.enumerate().filter(((i, c)) => c == 1).map(((i, c)) => str(i)).join(", ")}$. The only within-cluster distances are $d(0,1) = #distances.at(0).at(1)$ and $d(2,3) = #distances.at(2).at(3)$, both at most $B$ #sym.checkmark.
+
+        *Multiplicity:* The fixture stores one canonical witness. Swapping the two cluster labels gives an equivalent second witness because the ILP distinguishes clusters only by index.
+      ]
+    }
+  ],
+)[
+  This direct $O(n^2 K)$ ILP encoding#footnote[Standard ILP formulation of diameter-bounded clustering; no specific literature key is currently registered in `references.bib`.] introduces one binary variable $x_(i,c)$ for each element $i$ and cluster $c$, forces every element into exactly one cluster, and forbids every pair with $d(i,j) > B$ from sharing a cluster ($n K$ variables and at most $n + n^2 K$ constraints).
+][
+  _Construction._ Given a Clustering instance on elements $X = {0, dots, n - 1}$ with cluster bound $K$ and diameter bound $B$, create binary variables $x_(i,c) in {0, 1}$ for every element $i in X$ and cluster $c in {0, dots, K - 1}$. Interpret $x_(i,c) = 1$ iff element $i$ is assigned to cluster $c$.
+
+  For every element $i$, add the assignment constraint $sum_(c=0)^(K-1) x_(i,c) = 1$. For every pair $i < j$ with $d(i,j) > B$ and every cluster $c$, add the conflict constraint $x_(i,c) + x_(j,c) <= 1$. Use the zero objective and minimize it, so the target is a pure feasibility ILP.
+
+  _Correctness._ ($arrow.r.double$) If the source instance has a feasible clustering, set $x_(i,c) = 1$ exactly for the cluster assigned to element $i$. Every element is assigned once, so all assignment equalities hold. Whenever $d(i,j) > B$, the source clustering never puts $i$ and $j$ together, so for every cluster $c$ at least one of $x_(i,c)$ or $x_(j,c)$ is 0 and every conflict inequality holds. ($arrow.l.double$) If the ILP is feasible, the assignment equalities choose exactly one cluster for each element. If some extracted cluster contained a pair $i, j$ with $d(i,j) > B$, then for that cluster $c$ we would have $x_(i,c) = x_(j,c) = 1$, contradicting the conflict inequality. Hence every extracted cluster has diameter at most $B$, so the extracted assignment is a feasible clustering using at most $K$ clusters.
+
+  _Variable mapping._ The implementation stores variable $x_(i,c)$ at index $i dot K + c$, i.e.\ consecutive blocks of $K$ variables per element.
+
+  _Solution extraction._ For each element $i$, scan the block $(x_(i,0), dots, x_(i,K-1))$ and return the unique cluster $c$ with value 1.
+]
+
 // 5. PartitionIntoCliques → MinimumCoveringByCliques (#889)
 #let pic_mcbc = load-example("PartitionIntoCliques", "MinimumCoveringByCliques")
 #let pic_mcbc_sol = pic_mcbc.solutions.at(0)
diff --git a/src/rules/clustering_ilp.rs b/src/rules/clustering_ilp.rs
@@ -0,0 +1,127 @@
+//! Reduction from Clustering to ILP (Integer Linear Programming).
+//!
+//! Use one binary assignment variable `x_{i,c}` for each element `i` and
+//! cluster `c`. Equality constraints force every element into exactly one
+//! cluster, and conflict constraints forbid any pair with distance above the
+//! diameter bound from sharing a cluster.
+
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::misc::Clustering;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+
+/// Result of reducing Clustering to ILP.
+#[derive(Debug, Clone)]
+pub struct ReductionClusteringToILP {
+    target: ILP<bool>,
+    num_elements: usize,
+    num_clusters: usize,
+}
+
+impl ReductionClusteringToILP {
+    fn var_index(&self, element: usize, cluster: usize) -> usize {
+        element * self.num_clusters + cluster
+    }
+}
+
+impl ReductionResult for ReductionClusteringToILP {
+    type Source = Clustering;
+    type Target = ILP<bool>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        (0..self.num_elements)
+            .map(|element| {
+                (0..self.num_clusters)
+                    .find(|&cluster| {
+                        let idx = self.var_index(element, cluster);
+                        idx < target_solution.len() && target_solution[idx] == 1
+                    })
+                    .unwrap_or(0)
+            })
+            .collect()
+    }
+}
+
+#[reduction(
+    overhead = {
+        num_vars = "num_elements * num_clusters",
+        num_constraints = "num_elements + num_elements^2 * num_clusters",
+    }
+)]
+impl ReduceTo<ILP<bool>> for Clustering {
+    type Result = ReductionClusteringToILP;
+
+    fn reduce_to(&self) -> Self::Result {
+        let num_elements = self.num_elements();
+        let num_clusters = self.num_clusters();
+        let num_vars = num_elements * num_clusters;
+        let mut constraints = Vec::new();
+
+        let var_index =
+            |element: usize, cluster: usize| -> usize { element * num_clusters + cluster };
+
+        for element in 0..num_elements {
+            let terms: Vec<(usize, f64)> = (0..num_clusters)
+                .map(|cluster| (var_index(element, cluster), 1.0))
+                .collect();
+            constraints.push(LinearConstraint::eq(terms, 1.0));
+        }
+
+        let distances = self.distances();
+        let diameter_bound = self.diameter_bound();
+        for (i, row) in distances.iter().enumerate() {
+            for (j, &distance) in row.iter().enumerate().skip(i + 1) {
+                if distance > diameter_bound {
+                    for cluster in 0..num_clusters {
+                        constraints.push(LinearConstraint::le(
+                            vec![(var_index(i, cluster), 1.0), (var_index(j, cluster), 1.0)],
+                            1.0,
+                        ));
+                    }
+                }
+            }
+        }
+
+        ReductionClusteringToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+            num_elements,
+            num_clusters,
+        }
+    }
+}
+
+#[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: "clustering_to_ilp",
+        build: || {
+            let source = Clustering::new(
+                vec![
+                    vec![0, 1, 3, 3],
+                    vec![1, 0, 3, 3],
+                    vec![3, 3, 0, 1],
+                    vec![3, 3, 1, 0],
+                ],
+                2,
+                1,
+            );
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
+                source,
+                SolutionPair {
+                    source_config: vec![0, 0, 1, 1],
+                    target_config: vec![1, 0, 1, 0, 0, 1, 0, 1],
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/clustering_ilp.rs"]
+mod tests;
diff --git a/src/rules/minimumfaultdetectiontestset_ilp.rs b/src/rules/minimumfaultdetectiontestset_ilp.rs
@@ -0,0 +1,141 @@
+//! Reduction from MinimumFaultDetectionTestSet to ILP.
+//!
+//! Each input-output pair becomes a binary decision variable. For every
+//! internal vertex, the ILP requires at least one selected pair whose coverage
+//! set contains that vertex. Minimizing the sum of the pair variables therefore
+//! recovers the minimum-size covering test set.
+
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::misc::MinimumFaultDetectionTestSet;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use std::collections::VecDeque;
+
+/// Result of reducing MinimumFaultDetectionTestSet to ILP<bool>.
+#[derive(Debug, Clone)]
+pub struct ReductionMFDTSToILP {
+    target: ILP<bool>,
+}
+
+impl ReductionResult for ReductionMFDTSToILP {
+    type Source = MinimumFaultDetectionTestSet;
+    type Target = ILP<bool>;
+
+    fn target_problem(&self) -> &ILP<bool> {
+        &self.target
+    }
+
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        target_solution.to_vec()
+    }
+}
+
+#[reduction(overhead = {
+    num_vars = "num_inputs * num_outputs",
+    num_constraints = "num_vertices",
+})]
+impl ReduceTo<ILP<bool>> for MinimumFaultDetectionTestSet {
+    type Result = ReductionMFDTSToILP;
+
+    fn reduce_to(&self) -> Self::Result {
+        fn reachable(adj: &[Vec<usize>], start: usize) -> Vec<bool> {
+            let mut seen = vec![false; adj.len()];
+            let mut queue = VecDeque::new();
+            seen[start] = true;
+            queue.push_back(start);
+
+            while let Some(vertex) = queue.pop_front() {
+                for &next in &adj[vertex] {
+                    if !seen[next] {
+                        seen[next] = true;
+                        queue.push_back(next);
+                    }
+                }
+            }
+
+            seen
+        }
+
+        let mut adj = vec![Vec::new(); self.num_vertices()];
+        let mut rev_adj = vec![Vec::new(); self.num_vertices()];
+        for &(tail, head) in self.arcs() {
+            adj[tail].push(head);
+            rev_adj[head].push(tail);
+        }
+
+        let input_reachability: Vec<Vec<bool>> = self
+            .inputs()
+            .iter()
+            .map(|&input| reachable(&adj, input))
+            .collect();
+        let output_reachability: Vec<Vec<bool>> = self
+            .outputs()
+            .iter()
+            .map(|&output| reachable(&rev_adj, output))
+            .collect();
+
+        let mut boundary = vec![false; self.num_vertices()];
+        for &input in self.inputs() {
+            boundary[input] = true;
+        }
+        for &output in self.outputs() {
+            boundary[output] = true;
+        }
+
+        let num_pairs = self.num_inputs() * self.num_outputs();
+        let internal_vertices: Vec<usize> = (0..self.num_vertices())
+            .filter(|&vertex| !boundary[vertex])
+            .collect();
+
+        let constraints: Vec<LinearConstraint> = internal_vertices
+            .into_iter()
+            .map(|vertex| {
+                let mut terms = Vec::new();
+                for (input_idx, input_cov) in input_reachability.iter().enumerate() {
+                    for (output_idx, output_cov) in output_reachability.iter().enumerate() {
+                        if input_cov[vertex] && output_cov[vertex] {
+                            let pair_idx = input_idx * self.num_outputs() + output_idx;
+                            terms.push((pair_idx, 1.0));
+                        }
+                    }
+                }
+                LinearConstraint::ge(terms, 1.0)
+            })
+            .collect();
+
+        let objective = (0..num_pairs).map(|pair_idx| (pair_idx, 1.0)).collect();
+
+        ReductionMFDTSToILP {
+            target: ILP::new(num_pairs, constraints, objective, ObjectiveSense::Minimize),
+        }
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "minimumfaultdetectiontestset_to_ilp",
+        build: || {
+            let source = MinimumFaultDetectionTestSet::new(
+                7,
+                vec![
+                    (0, 2),
+                    (0, 3),
+                    (1, 3),
+                    (1, 4),
+                    (2, 5),
+                    (3, 5),
+                    (3, 6),
+                    (4, 6),
+                ],
+                vec![0, 1],
+                vec![5, 6],
+            );
+            crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/minimumfaultdetectiontestset_ilp.rs"]
+mod tests;
diff --git a/src/rules/mod.rs b/src/rules/mod.rs
@@ -164,6 +164,8 @@ pub(crate) mod capacityassignment_ilp;
 #[cfg(feature = "ilp-solver")]
 pub(crate) mod circuit_ilp;
 #[cfg(feature = "ilp-solver")]
+pub(crate) mod clustering_ilp;
+#[cfg(feature = "ilp-solver")]
 pub(crate) mod coloring_ilp;
 #[cfg(feature = "ilp-solver")]
 pub(crate) mod consecutiveblockminimization_ilp;
@@ -248,6 +250,8 @@ pub(crate) mod minimumedgecostflow_ilp;
 #[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumexternalmacrodatacompression_ilp;
 #[cfg(feature = "ilp-solver")]
+pub(crate) mod minimumfaultdetectiontestset_ilp;
+#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumfeedbackarcset_ilp;
 #[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumfeedbackvertexset_ilp;
@@ -531,6 +535,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         specs.extend(boundedcomponentspanningforest_ilp::canonical_rule_example_specs());
         specs.extend(capacityassignment_ilp::canonical_rule_example_specs());
         specs.extend(circuit_ilp::canonical_rule_example_specs());
+        specs.extend(clustering_ilp::canonical_rule_example_specs());
         specs.extend(coloring_ilp::canonical_rule_example_specs());
         specs.extend(consecutiveblockminimization_ilp::canonical_rule_example_specs());
         specs.extend(consecutiveonesmatrixaugmentation_ilp::canonical_rule_example_specs());
@@ -574,6 +579,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         specs.extend(minimumcoveringbycliques_ilp::canonical_rule_example_specs());
         specs.extend(minimumedgecostflow_ilp::canonical_rule_example_specs());
         specs.extend(minimumexternalmacrodatacompression_ilp::canonical_rule_example_specs());
+        specs.extend(minimumfaultdetectiontestset_ilp::canonical_rule_example_specs());
         specs.extend(minimuminternalmacrodatacompression_ilp::canonical_rule_example_specs());
         specs.extend(minimumfeedbackarcset_ilp::canonical_rule_example_specs());
         specs.extend(minimumfeedbackvertexset_ilp::canonical_rule_example_specs());
diff --git a/src/unit_tests/reduction_graph.rs b/src/unit_tests/reduction_graph.rs
@@ -1,5 +1,7 @@
 //! Tests for ReductionGraph: discovery, path finding, and typed API.
 
+#[cfg(feature = "ilp-solver")]
+use crate::models::algebraic::ILP;
 use crate::models::decision::Decision;
 use crate::models::formula::KSatisfiability;
 use crate::models::misc::Clustering;
@@ -39,6 +41,14 @@ fn test_reduction_graph_discovers_k3coloring_to_clustering() {
     assert!(graph.has_direct_reduction::<KColoring<K3, SimpleGraph>, Clustering>());
 }
 
+#[cfg(feature = "ilp-solver")]
+#[test]
+fn test_reduction_graph_discovers_clustering_to_ilp() {
+    let graph = ReductionGraph::new();
+
+    assert!(graph.has_direct_reduction::<Clustering, ILP<bool>>());
+}
+
 // ---- Path finding (by name) ----
 
 #[test]
diff --git a/src/unit_tests/rules/clustering_ilp.rs b/src/unit_tests/rules/clustering_ilp.rs
diff --git a/src/unit_tests/rules/minimumfaultdetectiontestset_ilp.rs b/src/unit_tests/rules/minimumfaultdetectiontestset_ilp.rs
