Fix #242: [Model] MixedChinesePostman (#729)

* Add plan for #242: [Model] MixedChinesePostman

* Implement #242: [Model] MixedChinesePostman

* chore: remove plan file after implementation

* Fix MixedChinesePostman evaluate() to use both directions of undirected edges

The previous implementation only allowed traversals in the chosen
orientation direction, rejecting valid MCPP solutions. The real Mixed
Chinese Postman allows undirected edges to be traversed in either
direction during the walk. Fix by building the available-arc set with
both directions for connectivity checks and shortest-path computation,
while keeping oriented-only arcs for degree imbalance.

Also fix paper pred solve command to include --solver brute-force
(no ILP reduction path exists for this model).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GiggleLiu

docs/paper/reductions.typ

@@ -117,6 +117,7 @@
   "MinimumMultiwayCut": [Minimum Multiway Cut],
   "OptimalLinearArrangement": [Optimal Linear Arrangement],
   "RuralPostman": [Rural Postman],
+  "MixedChinesePostman": [Mixed Chinese Postman],
   "LongestCommonSubsequence": [Longest Common Subsequence],
   "ExactCoverBy3Sets": [Exact Cover by 3-Sets],
   "SubsetSum": [Subset Sum],
@@ -3570,6 +3571,97 @@ A classical NP-complete problem from Garey and Johnson @garey1979[Ch.~3, p.~76],
   ]
 }
 
+#{
+  let x = load-model-example("MixedChinesePostman", variant: (weight: "i32"))
+  let nv = x.instance.graph.num_vertices
+  let arcs = x.instance.graph.arcs
+  let edges = x.instance.graph.edges
+  let arc-weights = x.instance.arc_weights
+  let edge-weights = x.instance.edge_weights
+  let B = x.instance.bound
+  let config = x.optimal_config
+  let oriented = edges.enumerate().map(((i, e)) => if config.at(i) == 0 { e } else { (e.at(1), e.at(0)) })
+  let base-cost = arc-weights.sum() + edge-weights.sum()
+  let total-cost = 22
+  [
+    #problem-def("MixedChinesePostman")[
+      Given a mixed graph $G = (V, A, E)$ with directed arcs $A$, undirected edges $E$, integer lengths $l(e) >= 0$ for every $e in A union E$, and a bound $B in ZZ^+$, determine whether there exists a closed walk in $G$ that traverses every arc in its prescribed direction and every undirected edge at least once in some direction with total length at most $B$.
+    ][
+      Mixed Chinese Postman is the mixed-graph arc-routing problem ND25 in Garey and Johnson @garey1979. Papadimitriou proved the mixed case NP-complete even when all lengths are 1, the graph is planar, and the maximum degree is 3 @papadimitriou1976edge. In contrast, the pure undirected and pure directed cases are polynomial-time solvable via matching / circulation machinery @edmondsjohnson1973. The implementation here uses one binary variable per undirected edge orientation, so the search space contributes the $2^|E|$ factor visible in the registered exact bound.
+
+      *Example.* Consider the instance on #nv vertices with directed arcs $(v_0, v_1)$, $(v_1, v_2)$, $(v_2, v_3)$, $(v_3, v_0)$ of lengths $2, 3, 1, 4$ and undirected edges $\{v_0, v_2\}$, $\{v_1, v_3\}$, $\{v_0, v_4\}$, $\{v_4, v_2\}$ of lengths $2, 3, 1, 2$. The config $(1, 1, 0, 0)$ orients those edges as $(v_2, v_0)$, $(v_3, v_1)$, $(v_0, v_4)$, and $(v_4, v_2)$, producing a strongly connected digraph. The base traversal cost is #base-cost, and duplicating the shortest path $v_1 arrow v_2 arrow v_3$ adds 4 more, so the total cost is $#total-cost <= B = #B$, proving the answer is YES.
+
+      #pred-commands(
+        "pred create --example MixedChinesePostman/i32 -o mixed-chinese-postman.json",
+        "pred solve mixed-chinese-postman.json --solver brute-force",
+        "pred evaluate mixed-chinese-postman.json --config " + x.optimal_config.map(str).join(","),
+      )
+
+      #figure(
+        canvas(length: 1cm, {
+          import draw: *
+          let positions = (
+            (-1.25, 0.85),
+            (1.25, 0.85),
+            (1.25, -0.85),
+            (-1.25, -0.85),
+            (0.25, 0.0),
+          )
+
+          for (idx, (u, v)) in arcs.enumerate() {
+            line(
+              positions.at(u),
+              positions.at(v),
+              stroke: 0.8pt + luma(80),
+              mark: (end: "straight", scale: 0.45),
+            )
+            let mid = (
+              (positions.at(u).at(0) + positions.at(v).at(0)) / 2,
+              (positions.at(u).at(1) + positions.at(v).at(1)) / 2,
+            )
+            content(
+              mid,
+              text(6pt, fill: luma(40))[#arc-weights.at(idx)],
+              fill: white,
+              frame: "rect",
+              padding: 0.04,
+              stroke: none,
+            )
+          }
+
+          for (idx, (u, v)) in oriented.enumerate() {
+            line(
+              positions.at(u),
+              positions.at(v),
+              stroke: 1.3pt + graph-colors.at(0),
+              mark: (end: "straight", scale: 0.5),
+            )
+            let mid = (
+              (positions.at(u).at(0) + positions.at(v).at(0)) / 2,
+              (positions.at(u).at(1) + positions.at(v).at(1)) / 2,
+            )
+            let offset = if idx == 0 { (-0.18, 0.12) } else if idx == 1 { (0.18, 0.12) } else if idx == 2 { (-0.12, -0.1) } else { (0.12, -0.1) }
+            content(
+              (mid.at(0) + offset.at(0), mid.at(1) + offset.at(1)),
+              text(6pt, fill: graph-colors.at(0))[#edge-weights.at(idx)],
+              fill: white,
+              frame: "rect",
+              padding: 0.04,
+              stroke: none,
+            )
+          }
+
+          for (i, pos) in positions.enumerate() {
+            circle(pos, radius: 0.18, fill: white, stroke: 0.6pt + black)
+            content(pos, text(7pt)[$v_#i$])
+          }
+        }),
+        caption: [Mixed Chinese Postman example. Gray arrows are the original directed arcs, while blue arrows are the chosen orientations of the former undirected edges under config $(1, 1, 0, 0)$. Duplicating the path $v_1 arrow v_2 arrow v_3$ yields total cost #total-cost.],
+      ) <fig:mixed-chinese-postman>
+    ]
+  ]
+}
+
 #{
   let x = load-model-example("SubgraphIsomorphism")
   let nv-host = x.instance.host_graph.num_vertices

docs/paper/references.bib

@@ -1282,3 +1282,22 @@ @inproceedings{williams2002
   pages     = {299--307},
   year      = {2002}
 }
+
+@article{papadimitriou1976edge,
+  author  = {Christos H. Papadimitriou},
+  title   = {On the Complexity of Edge Traversing},
+  journal = {Journal of the ACM},
+  volume  = {23},
+  number  = {3},
+  pages   = {544--554},
+  year    = {1976}
+}
+
+@article{edmondsjohnson1973,
+  author  = {Jack Edmonds and Ellis L. Johnson},
+  title   = {Matching, Euler Tours and the Chinese Postman},
+  journal = {Mathematical Programming},
+  volume  = {5},
+  pages   = {88--124},
+  year    = {1973}
+}

problemreductions-cli/src/cli.rs

@@ -265,6 +265,7 @@ Flags by problem type:
   SequencingWithinIntervals       --release-times, --deadlines, --lengths
   OptimalLinearArrangement        --graph, --bound
   MinMaxMulticenter (pCenter)     --graph, --weights, --edge-weights, --k, --bound
+  MixedChinesePostman (MCPP)      --graph, --arcs, --edge-weights, --arc-costs, --bound [--num-vertices]
   RuralPostman (RPP)              --graph, --edge-weights, --required-edges, --bound
   MultipleChoiceBranching         --arcs [--weights] --partition --bound [--num-vertices]
   AdditionalKey                   --num-attributes, --dependencies, --relation-attrs [--known-keys]

problemreductions-cli/src/commands/create.rs

@@ -13,7 +13,7 @@ use problemreductions::models::algebraic::{
 use problemreductions::models::formula::Quantifier;
 use problemreductions::models::graph::{
     GeneralizedHex, GraphPartitioning, HamiltonianCircuit, HamiltonianPath,
-    LengthBoundedDisjointPaths, MinimumCutIntoBoundedSets, MinimumMultiwayCut,
+    LengthBoundedDisjointPaths, MinimumCutIntoBoundedSets, MinimumMultiwayCut, MixedChinesePostman,
     MultipleChoiceBranching, SteinerTree, SteinerTreeInGraphs, StrongConnectivityAugmentation,
 };
 use problemreductions::models::misc::{
@@ -31,8 +31,8 @@ use problemreductions::models::BiconnectivityAugmentation;
 use problemreductions::prelude::*;
 use problemreductions::registry::collect_schemas;
 use problemreductions::topology::{
-    BipartiteGraph, DirectedGraph, Graph, KingsSubgraph, SimpleGraph, TriangularSubgraph,
-    UnitDiskGraph,
+    BipartiteGraph, DirectedGraph, Graph, KingsSubgraph, MixedGraph, SimpleGraph,
+    TriangularSubgraph, UnitDiskGraph,
 };
 use serde::Serialize;
 use std::collections::{BTreeMap, BTreeSet};
@@ -584,6 +584,9 @@ fn example_for(canonical: &str, graph_type: Option<&str>) -> &'static str {
         "StrongConnectivityAugmentation" => {
             "--arcs \"0>1,1>2\" --candidate-arcs \"2>0:1\" --bound 1"
         }
+        "MixedChinesePostman" => {
+            "--graph 0-2,1-3,0-4,4-2 --arcs \"0>1,1>2,2>3,3>0\" --edge-weights 2,3,1,2 --arc-costs 2,3,1,4 --bound 24"
+        }
         "RuralPostman" => {
             "--graph 0-1,1-2,2-3,3-0 --edge-weights 1,1,1,1 --required-edges 0,2 --bound 4"
         }
@@ -643,7 +646,12 @@ fn example_for(canonical: &str, graph_type: Option<&str>) -> &'static str {
 fn uses_edge_weights_flag(canonical: &str) -> bool {
     matches!(
         canonical,
-        "KthBestSpanningTree" | "MaxCut" | "MaximumMatching" | "TravelingSalesman" | "RuralPostman"
+        "KthBestSpanningTree"
+            | "MaxCut"
+            | "MaximumMatching"
+            | "TravelingSalesman"
+            | "RuralPostman"
+            | "MixedChinesePostman"
     )
 }
 
@@ -661,6 +669,7 @@ fn help_flag_name(canonical: &str, field_name: &str) -> String {
         ("PrimeAttributeName", "num_attributes") => return "universe".to_string(),
         ("PrimeAttributeName", "dependencies") => return "deps".to_string(),
         ("PrimeAttributeName", "query_attribute") => return "query".to_string(),
+        ("MixedChinesePostman", "arc_weights") => return "arc-costs".to_string(),
         ("ConsecutiveOnesSubmatrix", "bound") => return "bound".to_string(),
         ("StaffScheduling", "shifts_per_schedule") => return "k".to_string(),
         ("TimetableDesign", "num_tasks") => return "num-tasks".to_string(),
@@ -827,6 +836,15 @@ fn print_problem_help(canonical: &str, graph_type: Option<&str>) -> Result<()> {
                 // DirectedGraph fields use --arcs, not --graph
                 let hint = type_format_hint(&field.type_name, graph_type);
                 eprintln!("  --{:<16} {} ({})", "arcs", field.description, hint);
+            } else if field.type_name == "MixedGraph" {
+                eprintln!(
+                    "  --{:<16} {} ({})",
+                    "graph", "Undirected edges E of the mixed graph", "edge list: 0-1,1-2,2-3"
+                );
+                eprintln!(
+                    "  --{:<16} {} ({})",
+                    "arcs", "Directed arcs A of the mixed graph", "directed arcs: 0>1,1>2,2>0"
+                );
             } else if field.type_name == "BipartiteGraph" {
                 eprintln!(
                     "  --{:<16} {} ({})",
@@ -876,6 +894,9 @@ fn problem_help_flag_name(
     if field_type == "DirectedGraph" {
         return "arcs".to_string();
     }
+    if field_type == "MixedGraph" {
+        return "graph".to_string();
+    }
     if canonical == "LengthBoundedDisjointPaths" && field_name == "max_length" {
         return "bound".to_string();
     }
@@ -3003,9 +3024,10 @@ pub fn create(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
         // AcyclicPartition
         "AcyclicPartition" => {
             let usage = "Usage: pred create AcyclicPartition/i32 --arcs \"0>1,0>2,1>3,1>4,2>4,2>5,3>5,4>5\" --weights 2,3,2,1,3,1 --arc-costs 1,1,1,1,1,1,1,1 --weight-bound 5 --cost-bound 5";
-            let arcs_str = args.arcs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("AcyclicPartition requires --arcs\n\n{usage}")
-            })?;
+            let arcs_str = args
+                .arcs
+                .as_deref()
+                .ok_or_else(|| anyhow::anyhow!("AcyclicPartition requires --arcs\n\n{usage}"))?;
             let (graph, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)?;
             let vertex_weights = parse_vertex_weights(args, graph.num_vertices())?;
             let arc_costs = parse_arc_costs(args, num_arcs)?;
@@ -3109,6 +3131,46 @@ pub fn create(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
             )
         }
 
+        // MixedChinesePostman
+        "MixedChinesePostman" => {
+            let usage = "Usage: pred create MixedChinesePostman --graph 0-2,1-3,0-4,4-2 --arcs \"0>1,1>2,2>3,3>0\" --edge-weights 2,3,1,2 --arc-costs 2,3,1,4 --bound 24 [--num-vertices N]";
+            let graph = parse_mixed_graph(args, usage)?;
+            let arc_costs = parse_arc_costs(args, graph.num_arcs())?;
+            let edge_weights = parse_edge_weights(args, graph.num_edges())?;
+            let bound = args.bound.ok_or_else(|| {
+                anyhow::anyhow!("MixedChinesePostman requires --bound\n\n{usage}")
+            })?;
+            let bound = i32::try_from(bound).map_err(|_| {
+                anyhow::anyhow!(
+                    "MixedChinesePostman --bound must fit in i32 (got {bound})\n\n{usage}"
+                )
+            })?;
+            if arc_costs.iter().any(|&cost| cost < 0) {
+                bail!("MixedChinesePostman --arc-costs must be non-negative\n\n{usage}");
+            }
+            if edge_weights.iter().any(|&weight| weight < 0) {
+                bail!("MixedChinesePostman --edge-weights must be non-negative\n\n{usage}");
+            }
+            if resolved_variant.get("weight").map(|w| w.as_str()) == Some("One")
+                && (arc_costs.iter().any(|&cost| cost != 1)
+                    || edge_weights.iter().any(|&weight| weight != 1))
+            {
+                bail!(
+                    "Non-unit lengths are not supported for MixedChinesePostman/One.\n\n\
+                     Use the weighted variant instead:\n  pred create MixedChinesePostman/i32 --graph ... --arcs ... --edge-weights ... --arc-costs ..."
+                );
+            }
+            (
+                ser(MixedChinesePostman::new(
+                    graph,
+                    arc_costs,
+                    edge_weights,
+                    bound,
+                ))?,
+                resolved_variant.clone(),
+            )
+        }
+
         // MinimumSumMulticenter (p-median)
         "MinimumSumMulticenter" => {
             let (graph, n) = parse_graph(args).map_err(|e| {
@@ -4759,6 +4821,22 @@ fn parse_directed_graph(
     Ok((DirectedGraph::new(num_v, arcs), num_arcs))
 }
 
+fn parse_mixed_graph(args: &CreateArgs, usage: &str) -> Result<MixedGraph> {
+    let (undirected_graph, num_vertices) =
+        parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
+    let arcs_str = args
+        .arcs
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("MixedChinesePostman requires --arcs\n\n{usage}"))?;
+    let (directed_graph, _) = parse_directed_graph(arcs_str, Some(num_vertices))
+        .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
+    Ok(MixedGraph::new(
+        num_vertices,
+        directed_graph.arcs(),
+        undirected_graph.edges(),
+    ))
+}
+
 /// Parse `--weights` as arc weights (i32), defaulting to all 1s.
 fn parse_arc_weights(args: &CreateArgs, num_arcs: usize) -> Result<Vec<i32>> {
     match &args.weights {
@@ -4789,11 +4867,7 @@ fn parse_arc_costs(args: &CreateArgs, num_arcs: usize) -> Result<Vec<i32>> {
                 .map(|s| s.trim().parse::<i32>())
                 .collect::<std::result::Result<Vec<_>, _>>()?;
             if parsed.len() != num_arcs {
-                bail!(
-                    "Expected {} arc costs but got {}",
-                    num_arcs,
-                    parsed.len()
-                );
+                bail!("Expected {} arc costs but got {}", num_arcs, parsed.len());
             }
             Ok(parsed)
         }