fix: align ILP models and solver pipelines

Author: isPANN

docs/paper/reductions.typ

@@ -1796,33 +1796,6 @@ @article{yannakakis1980
   doi     = {10.1137/0138030}
 }
 
-@inproceedings{edmonds1970,
-  author    = {Jack Edmonds},
-  title     = {Submodular functions, matroids, and certain polyhedra},
-  booktitle = {Combinatorial Structures and Their Applications},
-  pages     = {69--87},
-  year      = {1970},
-  publisher = {Gordon and Breach}
-}
-
-@article{doron2024,
-  author  = {Ilan Doron-Arad and Ariel Kulik and Hadas Shachnai},
-  title   = {You (Almost) Can't Beat Brute Force for 3-Matroid Intersection},
-  journal = {arXiv preprint arXiv:2412.02217},
-  year    = {2024}
-}
-
-@article{fomin2019,
-  author  = {Fedor V. Fomin and Daniel Lokshtanov and Fahad Panolan and Saket Saurabh},
-  title   = {Exact Algorithms via Monotone Local Search},
-  journal = {Journal of the ACM},
-  volume  = {66},
-  number  = {2},
-  pages   = {1--23},
-  year    = {2019},
-  doi     = {10.1145/3277568}
-}
-
 @book{vonNeumannMorgenstern1944,
   author    = {John von Neumann and Oskar Morgenstern},
   title     = {Theory of Games and Economic Behavior},

docs/paper/references.bib

@@ -443,7 +443,7 @@ proved infeasibility, and `Err` reports an operational failure.
 | Solver | Description |
 |--------|-------------|
 | **BruteForce** | Enumerates a registered finite search space and returns an optimal or satisfying solution. Used for testing and verification. |
-| **ILPSolver** | Solves `ILP<bool>` and `ILP<i64>` instances directly with HiGHS via `good_lp`. Also provides `solve_reduced::<V, _>()` for problems that implement `ReduceTo<ILP<V>>`. |
+| **ILPSolver** | Executes a problem's registered ILP pipeline. Each pipeline terminates at `ILP<bool, f64>` or `ILP<i64, f64>`, which is solved by HiGHS via `good_lp`. |
 
 ## JSON Serialization
 

docs/src/design.md

@@ -96,20 +96,20 @@ assert!(metric.is_valid());
 Packing solution: [1, 0, 1, 1] -> size Max(3)
 ```
 
-For convenience, `ILPSolver::solve_reduced` combines reduce + solve + extract
-in a single call:
+`ILPSolver::solve` executes the problem's registered ILP pipeline, including
+all reductions and reverse witness extraction:
 
 ```rust,ignore
 let solution = ILPSolver::new()
-    .solve_reduced::<bool, _>(&problem)
+    .solve(&problem)
     .unwrap();
 assert!(problem.evaluate(&solution).is_valid());
 ```
 
-The ILP domain is explicit because a source type may provide more than one
-direct ILP reduction. Both `bool` and `i64` are supported. `solve` and
-`solve_reduced` return `ILPSolveError`, which distinguishes infeasibility,
-timeout, unboundedness, unsupported dynamic input, and backend failure.
+The registered path determines the ILP variable domain. Every path ends at an
+`ILP<V, f64>` terminal accepted by the HiGHS backend. `solve` returns
+`ILPSolveError`, which distinguishes infeasibility, timeout, unboundedness,
+missing pipelines, unsupported dynamic input, and backend failure.
 
 ### Example 2: Reduction path search — integer factoring to spin glass
 
@@ -145,10 +145,9 @@ returning the canonical pair **2 × 3**.
 
 #### Step 3 — Solve with ILPSolver
 
-`solve_reduced` reduces the problem to ILP internally and solves it in one
-call. It returns a configuration vector for the original problem — no manual
-extraction needed. For small instances you can also use `BruteForce`, but
-`ILPSolver` scales to much larger problems.
+`solve` executes the registered ILP pipeline and returns a configuration for
+the original problem — no manual extraction needed. For small instances you
+can also use `BruteForce`, but `ILPSolver` scales to much larger problems.
 
 ```rust,ignore
 {{#include ../../examples/chained_reduction_factoring_to_spinglass.rs:step3}}

docs/src/getting-started.md

@@ -563,7 +563,7 @@ mod tests {
     fn solve_result_json_preserves_structured_solver_contract() {
         let result = SolveResult {
             solver: problemreductions::solvers::SolverExecution::Ilp {
-                reduction_path: vec!["Source".to_string(), "ILP<bool>".to_string()],
+                reduction_path: vec!["Source".to_string(), "ILP<i64, bool>".to_string()],
             },
             outcome: SolveOutcome::Optimal {
                 solution: serde_json::json!([true, false]),
@@ -577,7 +577,7 @@ mod tests {
         assert_eq!(json["status"], "optimal");
         assert_eq!(
             json["solver"]["reduction_path"],
-            serde_json::json!(["Source", "ILP<bool>"])
+            serde_json::json!(["Source", "ILP<i64, bool>"])
         );
         assert_eq!(json["solution"], serde_json::json!([true, false]));
         assert!(json.get("reduced_to").is_none());

problemreductions-cli/src/dispatch.rs

@@ -39,9 +39,6 @@ pub fn resolve_alias(input: &str) -> String {
     if input.eq_ignore_ascii_case("MinimumCodeGenerationParallelAssignments") {
         return "MinimumCodeGenerationParallelAssignments".to_string();
     }
-    if input.eq_ignore_ascii_case("ThreeMatroidIntersection") {
-        return "ThreeMatroidIntersection".to_string();
-    }
     if let Some((entry, _)) = problemreductions::registry::find_variant_by_alias(input) {
         return entry.name.to_string();
     }
@@ -140,6 +137,23 @@ fn resolve_variant_updates(
     let mut updated_dimensions = BTreeSet::new();
 
     for token in &spec.variant_values {
+        if let Some((dimension, value)) = token.split_once('=') {
+            let values = token_index.get(dimension).ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Unknown variant dimension \"{dimension}\" for {}",
+                    spec.name
+                )
+            })?;
+            if !values.contains(value) {
+                anyhow::bail!("Unknown value \"{value}\" for variant dimension \"{dimension}\"");
+            }
+            if !updated_dimensions.insert(dimension.to_string()) {
+                anyhow::bail!("Variant dimension \"{dimension}\" was specified more than once");
+            }
+            resolved.insert(dimension.to_string(), value.to_string());
+            continue;
+        }
+
         let matching_dimensions = token_index
             .iter()
             .filter(|(_, values)| values.contains(token))
@@ -368,6 +382,14 @@ mod tests {
         assert_eq!(spec.variant_values, vec!["SimpleGraph", "f64"]);
     }
 
+    #[test]
+    fn resolve_problem_ref_accepts_named_variant_dimension() {
+        let graph = problemreductions::rules::ReductionGraph::new();
+        let resolved = resolve_problem_ref("ILP/variable=i64", &graph).unwrap();
+        assert_eq!(resolved.variant["variable"], "i64");
+        assert_eq!(resolved.variant["coefficient"], "i64");
+    }
+
     #[test]
     fn test_resolve_alias_pass_through_undirected_two_commodity_integral_flow() {
         assert_eq!(

problemreductions-cli/src/problem_name.rs

@@ -127,7 +127,7 @@ impl AggregateReductionResult for AggregateValueToIlpReduction {
         &self.target
     }
 
-    fn extract_value(&self, _target_value: Extremum<f64>) -> Max<i64> {
+    fn extract_value(&self, _target_value: Extremum<i64>) -> Max<i64> {
         Max(Some(0))
     }
 }

problemreductions-cli/src/test_support.rs

@@ -3527,7 +3527,7 @@ fn test_solve_direct_ilp_i64_problem() {
             "--example",
             "SequencingToMinimizeWeightedCompletionTime",
             "--to",
-            "ILP/i64",
+            "ILP/variable=i64",
             "--example-side",
             "target",
         ])
@@ -5013,6 +5013,60 @@ fn test_create_length_bounded_disjoint_paths_succeeds() {
     assert_eq!(json["data"]["max_length"], 2);
 }
 
+#[test]
+fn test_solve_length_bounded_disjoint_paths_with_chord() {
+    use std::io::Write;
+    use std::process::Stdio;
+
+    let created = pred()
+        .args([
+            "create",
+            "LengthBoundedDisjointPaths",
+            "--graph",
+            "0-1,1-2,0-2",
+            "--source",
+            "0",
+            "--sink",
+            "2",
+            "--max-length",
+            "2",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        created.status.success(),
+        "{}",
+        String::from_utf8_lossy(&created.stderr)
+    );
+    let mut child = pred()
+        .args(["solve", "-", "--json", "--quiet"])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    child
+        .stdin
+        .take()
+        .unwrap()
+        .write_all(&created.stdout)
+        .unwrap();
+    let solved = child.wait_with_output().unwrap();
+    assert!(
+        solved.status.success(),
+        "{}",
+        String::from_utf8_lossy(&solved.stderr)
+    );
+    let json: serde_json::Value = serde_json::from_slice(&solved.stdout).unwrap();
+    assert_eq!(json["status"], "optimal");
+    assert_eq!(json["solver"]["kind"], "ilp");
+    assert_eq!(json["evaluation"], "Max(2)");
+    let paths = json["solution"].as_array().unwrap();
+    assert_eq!(paths.len(), 2);
+    assert!(paths.contains(&serde_json::json!([true, true, false])));
+    assert!(paths.contains(&serde_json::json!([false, false, true])));
+}
+
 #[test]
 fn test_create_length_bounded_disjoint_paths_rejects_negative_bound_value() {
     let output = pred()
@@ -9058,7 +9112,7 @@ fn test_create_minimum_multiway_cut_rejects_single_terminal() {
 }
 
 #[test]
-fn test_create_sequencing_within_intervals_rejects_empty_window() {
+fn test_create_and_solve_sequencing_within_intervals_empty_window() {
     let output = pred()
         .args([
             "create",
@@ -9072,16 +9126,35 @@ fn test_create_sequencing_within_intervals_rejects_empty_window() {
         ])
         .output()
         .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        !stderr.contains("panicked at"),
-        "expected graceful CLI error, got panic: {stderr}"
-    );
-    assert!(
-        stderr.contains("task 0 has an empty time window"),
-        "expected empty-window validation error, got: {stderr}"
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
     );
+    for solver in ["brute-force", "ilp"] {
+        use std::io::Write;
+        let mut child = pred()
+            .args(["solve", "-", "--solver", solver, "--json"])
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .spawn()
+            .unwrap();
+        child
+            .stdin
+            .take()
+            .unwrap()
+            .write_all(&output.stdout)
+            .unwrap();
+        let solved = child.wait_with_output().unwrap();
+        assert!(
+            solved.status.success(),
+            "{}",
+            String::from_utf8_lossy(&solved.stderr)
+        );
+        let json: serde_json::Value = serde_json::from_slice(&solved.stdout).unwrap();
+        assert_eq!(json["status"], "infeasible");
+    }
 }
 
 #[test]
@@ -9118,11 +9191,11 @@ fn test_create_sequencing_within_intervals_rejects_overflow() {
             "create",
             "SequencingWithinIntervals",
             "--release-times",
-            "9223372036854775807",
+            "0",
             "--deadlines",
             "9223372036854775807",
             "--lengths",
-            "1",
+            "0",
         ])
         .output()
         .unwrap();
@@ -9133,7 +9206,7 @@ fn test_create_sequencing_within_intervals_rejects_overflow() {
         "expected graceful CLI error, got panic: {stderr}"
     );
     assert!(
-        stderr.contains("task 0 release time plus length overflows i64"),
+        stderr.contains("task start-slot count overflows i64"),
         "expected overflow validation error, got: {stderr}"
     );
 }

problemreductions-cli/tests/cli_tests.rs

@@ -75,6 +75,30 @@ where
     <S as ReduceTo<crate::models::algebraic::ILP<V>>>::Result:
         ReductionResult<Source = S, Target = crate::models::algebraic::ILP<V>>,
     S::Solution: Serialize,
+{
+    rule_example_via_typed_ilp::<S, V, i64>(source)
+}
+
+/// Float-coefficient counterpart of [`rule_example_via_ilp`].
+pub fn rule_example_via_float_ilp<S, V>(source: S) -> RuleExample
+where
+    S: Problem + Serialize + ReduceTo<crate::models::algebraic::ILP<V, f64>>,
+    V: crate::models::algebraic::VariableDomain,
+    <S as ReduceTo<crate::models::algebraic::ILP<V, f64>>>::Result:
+        ReductionResult<Source = S, Target = crate::models::algebraic::ILP<V, f64>>,
+    S::Solution: Serialize,
+{
+    rule_example_via_typed_ilp::<S, V, f64>(source)
+}
+
+fn rule_example_via_typed_ilp<S, V, C>(source: S) -> RuleExample
+where
+    S: Problem + Serialize + ReduceTo<crate::models::algebraic::ILP<V, C>>,
+    V: crate::models::algebraic::VariableDomain,
+    C: crate::models::algebraic::ILPCoefficient + Serialize,
+    <S as ReduceTo<crate::models::algebraic::ILP<V, C>>>::Result:
+        ReductionResult<Source = S, Target = crate::models::algebraic::ILP<V, C>>,
+    S::Solution: Serialize,
 {
     use crate::export::SolutionPair;
     let reduction = source.reduce_to().expect("reduction should succeed");

src/example_db/specs.rs

@@ -97,7 +97,6 @@ pub mod prelude {
         ComparativeContainment, ConsecutiveSets, ExactCoverBy3Sets, IntegerKnapsack,
         MaximumSetPacking, MinimumCardinalityKey, MinimumHittingSet, MinimumSetCovering,
         PrimeAttributeName, RootedTreeStorageAssignment, SetBasis, SetSplitting,
-        ThreeMatroidIntersection,
     };
 
     // Core traits