Implement #122: Add SteinerTree model

- Add SteinerTree<G, W> problem model (edge-based minimization)
- Register in graph/mod.rs, prelude, CLI dispatch/aliases/create
- Add --terminals CLI flag for pred create SteinerTree
- 12 unit tests: creation, evaluation, brute-force, serialization
- Add paper entry with Dreyfus-Wagner complexity and example figure
- Regenerate problem_schemas.json and reduction_graph.json

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

Author: zazabap

docs/paper/reductions.typ

@@ -51,6 +51,7 @@
   "BicliqueCover": [Biclique Cover],
   "BinPacking": [Bin Packing],
   "ClosestVectorProblem": [Closest Vector Problem],
+  "SteinerTree": [Steiner Tree],
 )
 
 // Definition label: "def:<ProblemName>" — each definition block must have a matching label
@@ -455,6 +456,45 @@ One of the most intensely studied NP-hard problems, with applications in logisti
 caption: [Complete graph $K_4$ with weighted edges. The optimal tour $v_0 -> v_1 -> v_2 -> v_3 -> v_0$ (blue edges) has cost 6.],
 ) <fig:k4-tsp>
 ]
+#problem-def("SteinerTree")[
+  Given an undirected graph $G = (V, E)$ with edge weights $w: E -> RR_(>= 0)$ and a set of terminal vertices $T subset.eq V$ with $|T| >= 2$, find a tree $S = (V_S, E_S)$ in $G$ such that $T subset.eq V_S$, minimizing $sum_(e in E_S) w(e)$. Vertices in $V_S backslash T$ are called _Steiner vertices_.
+][
+One of Karp's 21 NP-complete problems @karp1972, foundational in network design with applications in telecommunications backbone routing, VLSI chip interconnect, pipeline planning, and phylogenetic tree construction. When $T = V$, the problem reduces to the minimum spanning tree (polynomial). The NP-hardness arises from choosing which Steiner vertices to include.
+
+The best known exact algorithm runs in $O^*(3^(|T|) dot n + 2^(|T|) dot n^2)$ time via Dreyfus--Wagner dynamic programming over terminal subsets @dreyfuswagner1971. Byrka _et al._ achieved a $ln(4) + epsilon approx 1.39$-approximation @byrka2013; the classic 2-approximation uses the minimum spanning tree of the terminal distance graph.
+
+*Example.* Consider $G$ with $n = 5$ vertices, $m = 7$ edges, and terminals $T = {v_0, v_2, v_4}$. The optimal Steiner tree uses edges ${(v_0, v_1), (v_1, v_2), (v_1, v_3), (v_3, v_4)}$ with Steiner vertices ${v_1, v_3}$ acting as relay points. The total cost is $w(v_0, v_1) + w(v_1, v_2) + w(v_1, v_3) + w(v_3, v_4) = 2 + 2 + 1 + 1 = 6$. Note the only direct terminal--terminal edge $(v_2, v_4)$ has weight 6, equaling the entire Steiner tree cost.
+
+#figure({
+  // Layout: v0 top-left, v1 top-center, v2 top-right, v3 bottom-center, v4 bottom-right
+  let verts = ((0, 1.2), (1.2, 1.2), (2.4, 1.2), (1.2, 0), (2.4, 0))
+  let all-edges = ((0,1),(0,3),(1,2),(1,3),(2,3),(2,4),(3,4))
+  let tree-edges = ((0,1),(1,2),(1,3),(3,4))
+  let weights = ("2", "5", "2", "1", "5", "6", "1")
+  let terminals = (0, 2, 4)
+  canvas(length: 1cm, {
+    for (idx, (u, v)) in all-edges.enumerate() {
+      let on-tree = tree-edges.any(t => (t.at(0) == u and t.at(1) == v) or (t.at(0) == v and t.at(1) == u))
+      g-edge(verts.at(u), verts.at(v),
+        stroke: if on-tree { 2pt + graph-colors.at(0) } else { 1pt + luma(200) })
+      let mx = (verts.at(u).at(0) + verts.at(v).at(0)) / 2
+      let my = (verts.at(u).at(1) + verts.at(v).at(1)) / 2
+      let dx = if u == 0 and v == 3 { -0.3 } else if u == 2 and v == 3 { 0.3 } else { 0 }
+      let dy = if u == 0 and v == 1 { 0.2 } else if u == 1 and v == 2 { 0.2 } else if u == 2 and v == 4 { 0.3 } else { 0 }
+      draw.content((mx + dx, my + dy), text(7pt, fill: luma(80))[#weights.at(idx)])
+    }
+    for (k, pos) in verts.enumerate() {
+      let is-terminal = terminals.any(t => t == k)
+      g-node(pos, name: "v" + str(k),
+        fill: if is-terminal { graph-colors.at(0) } else { white },
+        stroke: if is-terminal { none } else { 1pt + graph-colors.at(0) },
+        label: text(fill: if is-terminal { white } else { black })[$v_#k$])
+    }
+  })
+},
+caption: [Steiner tree on 5 vertices with terminals $T = {v_0, v_2, v_4}$ (filled blue). Steiner vertices $v_1, v_3$ (outlined) relay connections. Blue edges form the optimal tree with cost 6.],
+) <fig:steiner-tree>
+]
 #problem-def("MaximumClique")[
   Given $G = (V, E)$, find $K subset.eq V$ maximizing $|K|$ such that all pairs in $K$ are adjacent: $forall u, v in K: (u, v) in E$. Equivalent to MIS on the complement graph $overline(G)$.
 ][

docs/paper/references.bib

@@ -366,3 +366,24 @@ @article{alber2004
   doi     = {10.1016/j.jalgor.2003.10.001}
 }
 
+@article{dreyfuswagner1971,
+  author  = {S. E. Dreyfus and R. A. Wagner},
+  title   = {The Steiner Problem in Graphs},
+  journal = {Networks},
+  volume  = {1},
+  number  = {3},
+  pages   = {195--207},
+  year    = {1971},
+  doi     = {10.1002/net.3230010302}
+}
+
+@article{byrka2013,
+  author  = {Jarosław Byrka and Fabrizio Grandoni and Thomas Rothvoß and Laura Sanità},
+  title   = {Steiner Tree Approximation via Iterative Randomized Rounding},
+  journal = {Journal of the ACM},
+  volume  = {60},
+  number  = {1},
+  pages   = {1--33},
+  year    = {2013},
+  doi     = {10.1145/2432622.2432628}
+}

docs/src/reductions/problem_schemas.json

@@ -8,16 +8,6 @@
         "type_name": "Vec<Vec<bool>>",
         "description": "Target boolean matrix A"
       },
-      {
-        "name": "m",
-        "type_name": "usize",
-        "description": "Number of rows"
-      },
-      {
-        "name": "n",
-        "type_name": "usize",
-        "description": "Number of columns"
-      },
       {
         "name": "k",
         "type_name": "usize",
@@ -75,11 +65,6 @@
         "name": "circuit",
         "type_name": "Circuit",
         "description": "The boolean circuit"
-      },
-      {
-        "name": "variables",
-        "type_name": "Vec<String>",
-        "description": "Circuit variable names"
       }
     ]
   },
@@ -337,24 +322,9 @@
     "description": "Minimize color changes in paint shop sequence",
     "fields": [
       {
-        "name": "sequence_indices",
-        "type_name": "Vec<usize>",
-        "description": "Car sequence as indices"
-      },
-      {
-        "name": "car_labels",
+        "name": "sequence",
         "type_name": "Vec<String>",
-        "description": "Unique car labels"
-      },
-      {
-        "name": "is_first",
-        "type_name": "Vec<bool>",
-        "description": "First occurrence flags"
-      },
-      {
-        "name": "num_cars",
-        "type_name": "usize",
-        "description": "Number of unique cars"
+        "description": "Car labels (each must appear exactly twice)"
       }
     ]
   },
@@ -411,6 +381,27 @@
       }
     ]
   },
+  {
+    "name": "SteinerTree",
+    "description": "Find minimum weight tree connecting terminal vertices",
+    "fields": [
+      {
+        "name": "graph",
+        "type_name": "G",
+        "description": "The underlying graph G=(V,E)"
+      },
+      {
+        "name": "edge_weights",
+        "type_name": "Vec<W>",
+        "description": "Edge weights w: E -> R"
+      },
+      {
+        "name": "terminals",
+        "type_name": "Vec<usize>",
+        "description": "Terminal vertices T that must be connected"
+      }
+    ]
+  },
   {
     "name": "TravelingSalesman",
     "description": "Find minimum weight Hamiltonian cycle in a graph (Traveling Salesman Problem)",

docs/src/reductions/reduction_graph.json

@@ -357,6 +357,26 @@
       "doc_path": "models/graph/struct.SpinGlass.html",
       "complexity": "2^num_spins"
     },
+    {
+      "name": "SteinerTree",
+      "variant": {
+        "graph": "SimpleGraph",
+        "weight": "One"
+      },
+      "category": "graph",
+      "doc_path": "models/graph/struct.SteinerTree.html",
+      "complexity": "3^num_terminals * num_vertices + 2^num_terminals * num_vertices^2"
+    },
+    {
+      "name": "SteinerTree",
+      "variant": {
+        "graph": "SimpleGraph",
+        "weight": "i32"
+      },
+      "category": "graph",
+      "doc_path": "models/graph/struct.SteinerTree.html",
+      "complexity": "3^num_terminals * num_vertices + 2^num_terminals * num_vertices^2"
+    },
     {
       "name": "TravelingSalesman",
       "variant": {
@@ -1201,7 +1221,7 @@
       "doc_path": "rules/spinglass_casts/index.html"
     },
     {
-      "source": 39,
+      "source": 41,
       "target": 8,
       "overhead": [
         {

problemreductions-cli/src/cli.rs

@@ -326,6 +326,9 @@ pub struct CreateArgs {
     /// Variable bounds for CVP as "lower,upper" (e.g., "-10,10") [default: -10,10]
     #[arg(long, allow_hyphen_values = true)]
     pub bounds: Option<String>,
+    /// Terminal vertices for SteinerTree (comma-separated indices, e.g., "0,2,4")
+    #[arg(long)]
+    pub terminals: Option<String>,
 }
 
 #[derive(clap::Args)]

problemreductions-cli/src/commands/create.rs

@@ -45,6 +45,7 @@ fn all_data_flags_empty(args: &CreateArgs) -> bool {
         && args.basis.is_none()
         && args.target_vec.is_none()
         && args.bounds.is_none()
+        && args.terminals.is_none()
 }
 
 fn type_format_hint(type_name: &str, graph_type: Option<&str>) -> &'static str {
@@ -83,6 +84,7 @@ fn example_for(canonical: &str, graph_type: Option<&str>) -> &'static str {
         "SpinGlass" => "--graph 0-1,1-2 --couplings 1,1",
         "KColoring" => "--graph 0-1,1-2,2-0 --k 3",
         "Factoring" => "--target 15 --m 4 --n 4",
+        "SteinerTree" => "--graph 0-1,1-2,1-3,3-4 --edge-weights 2,2,1,1 --terminals 0,2,4",
         _ => "",
     }
 }
@@ -193,6 +195,19 @@ pub fn create(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
             create_vertex_weight_problem(args, canonical, graph_type, &resolved_variant)?
         }
 
+        // SteinerTree (graph + edge weights + terminals)
+        "SteinerTree" => {
+            let (graph, _) = parse_graph(args).map_err(|e| {
+                anyhow::anyhow!(
+                    "{e}\n\nUsage: pred create SteinerTree --graph 0-1,1-2,1-3,3-4 --edge-weights 2,2,1,1 --terminals 0,2,4"
+                )
+            })?;
+            let edge_weights = parse_edge_weights(args, graph.num_edges())?;
+            let terminals = parse_terminals(args, graph.num_vertices())?;
+            let data = ser(SteinerTree::new(graph, edge_weights, terminals))?;
+            (data, resolved_variant.clone())
+        }
+
         // Graph problems with edge weights
         "MaxCut" | "MaximumMatching" | "TravelingSalesman" => {
             let (graph, _) = parse_graph(args).map_err(|e| {
@@ -611,6 +626,27 @@ fn parse_vertex_weights(args: &CreateArgs, num_vertices: usize) -> Result<Vec<i3
     }
 }
 
+/// Parse `--terminals` as comma-separated vertex indices.
+fn parse_terminals(args: &CreateArgs, num_vertices: usize) -> Result<Vec<usize>> {
+    let s = args
+        .terminals
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("SteinerTree requires --terminals (e.g., \"0,2,4\")"))?;
+    let terminals: Vec<usize> = s
+        .split(',')
+        .map(|t| t.trim().parse::<usize>())
+        .collect::<std::result::Result<Vec<_>, _>>()
+        .context("invalid terminal index")?;
+    for &t in &terminals {
+        anyhow::ensure!(
+            t < num_vertices,
+            "terminal {t} >= num_vertices ({num_vertices})"
+        );
+    }
+    anyhow::ensure!(terminals.len() >= 2, "at least 2 terminals required");
+    Ok(terminals)
+}
+
 /// Parse `--edge-weights` as edge weights (i32), defaulting to all 1s.
 fn parse_edge_weights(args: &CreateArgs, num_edges: usize) -> Result<Vec<i32>> {
     match &args.edge_weights {
@@ -893,6 +929,23 @@ fn create_random(
             (data, variant)
         }
 
+        // SteinerTree
+        "SteinerTree" => {
+            let edge_prob = args.edge_prob.unwrap_or(0.5);
+            if !(0.0..=1.0).contains(&edge_prob) {
+                bail!("--edge-prob must be between 0.0 and 1.0");
+            }
+            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
+            let edge_weights = vec![1i32; graph.num_edges()];
+            let num_terminals = std::cmp::max(2, num_vertices * 2 / 5);
+            let terminals: Vec<usize> = (0..num_terminals).collect();
+            let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
+            (
+                ser(SteinerTree::new(graph, edge_weights, terminals))?,
+                variant,
+            )
+        }
+
         // SpinGlass
         "SpinGlass" => {
             let edge_prob = args.edge_prob.unwrap_or(0.5);

problemreductions-cli/src/dispatch.rs

@@ -213,6 +213,7 @@ pub fn load_problem(
         "MaxCut" => deser_opt::<MaxCut<SimpleGraph, i32>>(data),
         "MaximalIS" => deser_opt::<MaximalIS<SimpleGraph, i32>>(data),
         "TravelingSalesman" => deser_opt::<TravelingSalesman<SimpleGraph, i32>>(data),
+        "SteinerTree" => deser_opt::<SteinerTree<SimpleGraph, i32>>(data),
         "KColoring" => match variant.get("k").map(|s| s.as_str()) {
             Some("K3") => deser_sat::<KColoring<K3, SimpleGraph>>(data),
             _ => deser_sat::<KColoring<KN, SimpleGraph>>(data),
@@ -269,6 +270,7 @@ pub fn serialize_any_problem(
         "MaxCut" => try_ser::<MaxCut<SimpleGraph, i32>>(any),
         "MaximalIS" => try_ser::<MaximalIS<SimpleGraph, i32>>(any),
         "TravelingSalesman" => try_ser::<TravelingSalesman<SimpleGraph, i32>>(any),
+        "SteinerTree" => try_ser::<SteinerTree<SimpleGraph, i32>>(any),
         "KColoring" => match variant.get("k").map(|s| s.as_str()) {
             Some("K3") => try_ser::<KColoring<K3, SimpleGraph>>(any),
             _ => try_ser::<KColoring<KN, SimpleGraph>>(any),

problemreductions-cli/src/problem_name.rs

@@ -22,6 +22,7 @@ pub const ALIASES: &[(&str, &str)] = &[
     ("BP", "BinPacking"),
     ("CVP", "ClosestVectorProblem"),
     ("MaxMatching", "MaximumMatching"),
+    ("ST", "SteinerTree"),
 ];
 
 /// Resolve a short alias to the canonical problem name.
@@ -52,6 +53,7 @@ pub fn resolve_alias(input: &str) -> String {
         "bicliquecover" => "BicliqueCover".to_string(),
         "bp" | "binpacking" => "BinPacking".to_string(),
         "cvp" | "closestvectorproblem" => "ClosestVectorProblem".to_string(),
+        "st" | "steinertree" | "steiner" => "SteinerTree".to_string(),
         _ => input.to_string(), // pass-through for exact names
     }
 }

src/lib.rs

@@ -41,7 +41,7 @@ pub mod prelude {
     pub use crate::models::graph::{BicliqueCover, SpinGlass};
     pub use crate::models::graph::{
         KColoring, MaxCut, MaximalIS, MaximumClique, MaximumIndependentSet, MaximumMatching,
-        MinimumDominatingSet, MinimumVertexCover, TravelingSalesman,
+        MinimumDominatingSet, MinimumVertexCover, SteinerTree, TravelingSalesman,
     };
     pub use crate::models::misc::{BinPacking, Factoring, PaintShop};
     pub use crate::models::set::{MaximumSetPacking, MinimumSetCovering};

src/models/graph/mod.rs

@@ -23,6 +23,7 @@ pub(crate) mod maximum_matching;
 pub(crate) mod minimum_dominating_set;
 pub(crate) mod minimum_vertex_cover;
 pub(crate) mod spin_glass;
+pub(crate) mod steiner_tree;
 pub(crate) mod traveling_salesman;
 
 pub use biclique_cover::BicliqueCover;
@@ -35,4 +36,5 @@ pub use maximum_matching::MaximumMatching;
 pub use minimum_dominating_set::MinimumDominatingSet;
 pub use minimum_vertex_cover::MinimumVertexCover;
 pub use spin_glass::SpinGlass;
+pub use steiner_tree::SteinerTree;
 pub use traveling_salesman::TravelingSalesman;