CodingThrust
diff --git a/‎docs/paper/reductions.typ‎
Lines changed: 240 additions & 0 deletions b/‎docs/paper/reductions.typ‎
Lines changed: 240 additions & 0 deletions
diff --git a/‎examples/export_module_graph.rs‎
Lines changed: 6 additions & 12 deletions b/‎examples/export_module_graph.rs‎
Lines changed: 6 additions & 12 deletions
diff --git a/‎problemreductions-cli/tests/cli_tests.rs‎
Lines changed: 44 additions & 24 deletions b/‎problemreductions-cli/tests/cli_tests.rs‎
Lines changed: 44 additions & 24 deletions
diff --git a/‎src/models/graph/undirected_two_commodity_integral_flow.rs‎
Lines changed: 7 additions & 1 deletion b/‎src/models/graph/undirected_two_commodity_integral_flow.rs‎
Lines changed: 7 additions & 1 deletion
diff --git a/‎src/rules/capacityassignment_ilp.rs‎
Lines changed: 140 additions & 0 deletions b/‎src/rules/capacityassignment_ilp.rs‎
Lines changed: 140 additions & 0 deletions
@@ -110,13 +110,11 @@ fn main() {
         (
             "traits",
             "core",
-            &[
-                (
-                    "Problem",
-                    "trait",
-                    "Core trait for all computational problems",
-                ),
-            ],
+            &[(
+                "Problem",
+                "trait",
+                "Core trait for all computational problems",
+            )],
         ),
         (
             "types",
@@ -160,11 +158,7 @@ fn main() {
             "rules",
             "rule",
             &[
-                (
-                    "ReduceTo",
-                    "trait",
-                    "Trait for witness/config reductions",
-                ),
+                ("ReduceTo", "trait", "Trait for witness/config reductions"),
                 (
                     "ReductionResult",
                     "trait",
 
@@ -1519,7 +1519,7 @@ fn test_create_d2cif_alias() {
 }
 
 #[test]
-fn test_solve_d2cif_default_solver_suggests_bruteforce() {
+fn test_solve_d2cif_default_solver_uses_ilp() {
     let output_file = std::env::temp_dir().join("pred_test_solve_d2cif.json");
     let create_output = pred()
         .args([
@@ -1557,21 +1557,25 @@ fn test_solve_d2cif_default_solver_suggests_bruteforce() {
         .output()
         .unwrap();
     assert!(
-        !solve_output.status.success(),
-        "stdout: {}",
-        String::from_utf8_lossy(&solve_output.stdout)
+        solve_output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&solve_output.stderr)
     );
-    let stderr = String::from_utf8_lossy(&solve_output.stderr);
+    let stdout = String::from_utf8(solve_output.stdout).unwrap();
     assert!(
-        stderr.contains("--solver brute-force"),
-        "expected brute-force hint, got: {stderr}"
+        stdout.contains("\"solver\": \"ilp\""),
+        "expected ILP solver output, got: {stdout}"
+    );
+    assert!(
+        stdout.contains("\"reduced_to\": \"ILP\""),
+        "expected auto-reduction marker, got: {stdout}"
     );
 
     std::fs::remove_file(&output_file).ok();
 }
 
 #[test]
-fn test_inspect_rectilinear_picture_compression_lists_bruteforce_only() {
+fn test_inspect_rectilinear_picture_compression_lists_ilp_and_bruteforce() {
     let output_file = std::env::temp_dir().join("pred_test_inspect_rpc.json");
     let create_output = pred()
         .args([
@@ -1604,8 +1608,8 @@ fn test_inspect_rectilinear_picture_compression_lists_bruteforce_only() {
     let stdout = String::from_utf8(inspect_output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert!(
-        json["solvers"] == serde_json::json!(["brute-force"]),
-        "inspect should list only usable solvers, got: {json}"
+        json["solvers"] == serde_json::json!(["ilp", "brute-force"]),
+        "inspect should list ILP first when available, got: {json}"
     );
 
     std::fs::remove_file(&output_file).ok();
@@ -4422,7 +4426,7 @@ fn test_create_minmaxmulticenter_negative_inputs_rejected() {
 }
 
 #[test]
-fn test_solve_minmaxmulticenter_ilp_error_suggests_bruteforce() {
+fn test_solve_minmaxmulticenter_default_solver_uses_ilp() {
     let problem_file = std::env::temp_dir().join("pred_test_minmaxmulticenter_solve.json");
     let create_out = pred()
         .args([
@@ -4449,9 +4453,17 @@ fn test_solve_minmaxmulticenter_ilp_error_suggests_bruteforce() {
         .args(["solve", problem_file.to_str().unwrap()])
         .output()
         .unwrap();
-    assert!(!solve_out.status.success());
-    let stderr = String::from_utf8_lossy(&solve_out.stderr);
-    assert!(stderr.contains("--solver brute-force"), "stderr: {stderr}");
+    assert!(
+        solve_out.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&solve_out.stderr)
+    );
+    let stdout = String::from_utf8(solve_out.stdout).unwrap();
+    assert!(stdout.contains("\"solver\": \"ilp\""), "stdout: {stdout}");
+    assert!(
+        stdout.contains("\"reduced_to\": \"ILP\""),
+        "stdout: {stdout}"
+    );
 
     std::fs::remove_file(&problem_file).ok();
 }
@@ -5644,7 +5656,7 @@ fn test_create_pipe_to_solve() {
 }
 
 #[test]
-fn test_solve_ilp_error_suggests_brute_force_fallback() {
+fn test_solve_sum_of_squares_partition_default_solver_uses_ilp() {
     let problem_json = r#"{
         "type": "SumOfSquaresPartition",
         "data": {
@@ -5660,12 +5672,20 @@ fn test_solve_ilp_error_suggests_brute_force_fallback() {
         .args(["solve", tmp.to_str().unwrap()])
         .output()
         .unwrap();
-    assert!(!output.status.success());
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
 
-    let stderr = String::from_utf8_lossy(&output.stderr);
+    let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(
-        stderr.contains("--solver brute-force"),
-        "stderr should suggest the brute-force fallback, got: {stderr}"
+        stdout.contains("\"solver\": \"ilp\""),
+        "stdout should report the ILP solver, got: {stdout}"
+    );
+    assert!(
+        stdout.contains("\"reduced_to\": \"ILP\""),
+        "stdout should report the ILP reduction target, got: {stdout}"
     );
 
     std::fs::remove_file(&tmp).ok();
@@ -5848,7 +5868,7 @@ fn test_inspect_problem() {
 }
 
 #[test]
-fn test_inspect_minmaxmulticenter_lists_bruteforce_only() {
+fn test_inspect_minmaxmulticenter_lists_ilp_and_bruteforce() {
     let problem_file = std::env::temp_dir().join("pred_test_inspect_minmaxmulticenter.json");
     let create_out = pred()
         .args([
@@ -5888,7 +5908,7 @@ fn test_inspect_minmaxmulticenter_lists_bruteforce_only() {
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
-    assert_eq!(solvers, vec!["brute-force"]);
+    assert_eq!(solvers, vec!["ilp", "brute-force"]);
 
     std::fs::remove_file(&problem_file).ok();
 }
@@ -6094,7 +6114,7 @@ fn test_inspect_json_output() {
 }
 
 #[test]
-fn test_inspect_multiprocessor_scheduling_reports_only_brute_force_solver() {
+fn test_inspect_multiprocessor_scheduling_reports_ilp_and_brute_force() {
     let problem_file = std::env::temp_dir().join("pred_test_inspect_mps_in.json");
     let result_file = std::env::temp_dir().join("pred_test_inspect_mps_out.json");
     let create_out = pred()
@@ -6143,7 +6163,7 @@ fn test_inspect_multiprocessor_scheduling_reports_only_brute_force_solver() {
         .collect();
     assert_eq!(
         solvers,
-        vec!["brute-force"],
+        vec!["ilp", "brute-force"],
         "unexpected solvers: {solvers:?}"
     );
 
@@ -6381,7 +6401,7 @@ fn test_inspect_multiple_copy_file_allocation_reports_size_fields() {
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
-    assert_eq!(solvers, vec!["brute-force"]);
+    assert_eq!(solvers, vec!["ilp", "brute-force"]);
 
     std::fs::remove_file(&problem_file).ok();
     std::fs::remove_file(&result_file).ok();
 
@@ -32,7 +32,7 @@ inventory::submit! {
 inventory::submit! {
     ProblemSizeFieldEntry {
         name: "UndirectedTwoCommodityIntegralFlow",
-        fields: &["num_vertices", "num_edges"],
+        fields: &["num_vertices", "num_edges", "num_nonterminal_vertices"],
     }
 }
 
@@ -149,6 +149,12 @@ impl UndirectedTwoCommodityIntegralFlow {
         self.graph.num_edges()
     }
 
+    pub fn num_nonterminal_vertices(&self) -> usize {
+        (0..self.num_vertices())
+            .filter(|&vertex| !self.is_terminal(vertex))
+            .count()
+    }
+
     pub fn is_valid_solution(&self, config: &[usize]) -> bool {
         self.evaluate(config).0
     }
 
@@ -0,0 +1,140 @@
+//! Reduction from CapacityAssignment to ILP (Integer Linear Programming).
+//!
+//! The Capacity Assignment feasibility problem can be formulated as a binary ILP:
+//! - Variables: Binary x_{l,c} (link l gets capacity c), one-hot per link
+//! - Constraints: Σ_c x_{l,c} = 1 for each link l (assignment);
+//!   Σ_{l,c} cost[l][c]·x_{l,c} ≤ cost_budget; Σ_{l,c} delay[l][c]·x_{l,c} ≤ delay_budget
+//! - Objective: Minimize 0 (feasibility)
+//! - Extraction: argmax_c x_{l,c} for each link l
+
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::misc::CapacityAssignment;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+
+/// Result of reducing CapacityAssignment to ILP.
+///
+/// Variable layout: x_{l,c} at index l * num_capacities + c.
+/// - l ∈ 0..num_links, c ∈ 0..num_capacities
+///
+/// Total: num_links * num_capacities variables.
+#[derive(Debug, Clone)]
+pub struct ReductionCAToILP {
+    target: ILP<bool>,
+    num_links: usize,
+    num_capacities: usize,
+}
+
+impl ReductionResult for ReductionCAToILP {
+    type Source = CapacityAssignment;
+    type Target = ILP<bool>;
+
+    fn target_problem(&self) -> &ILP<bool> {
+        &self.target
+    }
+
+    /// Extract solution: for each link l, find the unique capacity c where x_{l,c} = 1.
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        let num_capacities = self.num_capacities;
+        (0..self.num_links)
+            .map(|l| {
+                (0..num_capacities)
+                    .find(|&c| target_solution[l * num_capacities + c] == 1)
+                    .unwrap_or(0)
+            })
+            .collect()
+    }
+}
+
+#[reduction(
+    overhead = {
+        num_vars = "num_links * num_capacities",
+        num_constraints = "num_links + 2",
+    }
+)]
+impl ReduceTo<ILP<bool>> for CapacityAssignment {
+    type Result = ReductionCAToILP;
+
+    fn reduce_to(&self) -> Self::Result {
+        let num_links = self.num_links();
+        let num_capacities = self.num_capacities();
+        let num_vars = num_links * num_capacities;
+
+        let mut constraints = Vec::with_capacity(num_links + 2);
+
+        // Assignment constraints: for each link l, Σ_c x_{l,c} = 1
+        for l in 0..num_links {
+            let terms: Vec<(usize, f64)> = (0..num_capacities)
+                .map(|c| (l * num_capacities + c, 1.0))
+                .collect();
+            constraints.push(LinearConstraint::eq(terms, 1.0));
+        }
+
+        // Cost budget constraint: Σ_{l,c} cost[l][c] * x_{l,c} ≤ cost_budget
+        let cost_terms: Vec<(usize, f64)> = (0..num_links)
+            .flat_map(|l| {
+                (0..num_capacities).map(move |c| (l * num_capacities + c, self.cost()[l][c] as f64))
+            })
+            .collect();
+        constraints.push(LinearConstraint::le(cost_terms, self.cost_budget() as f64));
+
+        // Delay budget constraint: Σ_{l,c} delay[l][c] * x_{l,c} ≤ delay_budget
+        let delay_terms: Vec<(usize, f64)> = (0..num_links)
+            .flat_map(|l| {
+                (0..num_capacities)
+                    .map(move |c| (l * num_capacities + c, self.delay()[l][c] as f64))
+            })
+            .collect();
+        constraints.push(LinearConstraint::le(
+            delay_terms,
+            self.delay_budget() as f64,
+        ));
+
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+
+        ReductionCAToILP {
+            target,
+            num_links,
+            num_capacities,
+        }
+    }
+}
+
+#[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: "capacityassignment_to_ilp",
+        build: || {
+            // 2 links, 2 capacity levels
+            // cost: [[1,3],[2,4]], delay: [[8,4],[7,3]]
+            // budgets: cost=5, delay=12
+            // Solution: link 0 → cap 0 (cost=1, delay=8), link 1 → cap 0 (cost=2, delay=7)
+            // total cost=3 ≤ 5, total delay=15 > 12 -- try cap 1 for both
+            // link 0 → cap 1 (cost=3, delay=4), link 1 → cap 1 (cost=4, delay=3)
+            // total cost=7 > 5 -- try mixed: link 0 → cap 0, link 1 → cap 0: cost=3≤5, delay=15>12
+            // link 0 → cap 1 (cost=3, delay=4), link 1 → cap 0 (cost=2, delay=7): cost=5≤5, delay=11≤12
+            let source = CapacityAssignment::new(
+                vec![1, 2],
+                vec![vec![1, 3], vec![2, 4]],
+                vec![vec![8, 4], vec![7, 3]],
+                5,
+                12,
+            );
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
+                source,
+                SolutionPair {
+                    // link 0 → cap 1, link 1 → cap 0
+                    source_config: vec![1, 0],
+                    // x_{0,0}=0, x_{0,1}=1, x_{1,0}=1, x_{1,1}=0
+                    target_config: vec![0, 1, 1, 0],
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/capacityassignment_ilp.rs"]
+mod tests;
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ inventory::submit! {`
`32`	`32`	`inventory::submit! {`
`33`	`33`	`ProblemSizeFieldEntry {`
`34`	`34`	`name: "UndirectedTwoCommodityIntegralFlow",`
`35`		`- fields: &["num_vertices", "num_edges"],`
	`35`	`+ fields: &["num_vertices", "num_edges", "num_nonterminal_vertices"],`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`@@ -149,6 +149,12 @@ impl UndirectedTwoCommodityIntegralFlow {`
`149`	`149`	`self.graph.num_edges()`
`150`	`150`	`}`
`151`	`151`
	`152`	`+ pub fn num_nonterminal_vertices(&self) -> usize {`
	`153`	`+ (0..self.num_vertices())`
	`154`	`+ .filter(\|&vertex\| !self.is_terminal(vertex))`
	`155`	`+ .count()`
	`156`	`+ }`
	`157`	`+`
`152`	`158`	`pub fn is_valid_solution(&self, config: &[usize]) -> bool {`
`153`	`159`	`self.evaluate(config).0`
`154`	`160`	`}`