feat: add mvc to minimum weight and/or graph reduction

Author: GiggleLiu

src/rules/minimumvertexcover_minimumweightandorgraph.rs

@@ -0,0 +1,115 @@
+//! Reduction from MinimumVertexCover to MinimumWeightAndOrGraph.
+
+use crate::models::graph::MinimumVertexCover;
+use crate::models::misc::MinimumWeightAndOrGraph;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::topology::Graph;
+use crate::topology::SimpleGraph;
+
+/// Result of reducing MinimumVertexCover to MinimumWeightAndOrGraph.
+#[derive(Debug, Clone)]
+pub struct ReductionVCToAndOrGraph {
+    target: MinimumWeightAndOrGraph,
+    sink_arc_start: usize,
+    num_source_vertices: usize,
+}
+
+impl ReductionResult for ReductionVCToAndOrGraph {
+    type Source = MinimumVertexCover<SimpleGraph, i32>;
+    type Target = MinimumWeightAndOrGraph;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        (0..self.num_source_vertices)
+            .map(|j| usize::from(target_solution.get(self.sink_arc_start + j) == Some(&1)))
+            .collect()
+    }
+}
+
+#[reduction(
+    overhead = {
+        num_vertices = "1 + num_edges + 2 * num_vertices",
+        num_arcs = "3 * num_edges + num_vertices",
+    }
+)]
+impl ReduceTo<MinimumWeightAndOrGraph> for MinimumVertexCover<SimpleGraph, i32> {
+    type Result = ReductionVCToAndOrGraph;
+
+    fn reduce_to(&self) -> Self::Result {
+        let n = self.graph().num_vertices();
+        let edges = self.graph().edges();
+        let m = edges.len();
+
+        let num_target_vertices = 1 + m + (2 * n);
+        let mut gate_types = vec![None; num_target_vertices];
+        gate_types[0] = Some(true);
+        for gate in gate_types.iter_mut().skip(1).take(m + n) {
+            *gate = Some(false);
+        }
+
+        let edge_vertex = |i: usize| 1 + i;
+        let cover_vertex = |j: usize| 1 + m + j;
+        let sink_vertex = |j: usize| 1 + m + n + j;
+
+        let mut arcs = Vec::with_capacity((3 * m) + n);
+        let mut arc_weights = Vec::with_capacity((3 * m) + n);
+
+        for i in 0..m {
+            arcs.push((0, edge_vertex(i)));
+            arc_weights.push(1);
+        }
+
+        for (i, &(u, v)) in edges.iter().enumerate() {
+            arcs.push((edge_vertex(i), cover_vertex(u)));
+            arc_weights.push(1);
+            arcs.push((edge_vertex(i), cover_vertex(v)));
+            arc_weights.push(1);
+        }
+
+        let sink_arc_start = arcs.len();
+        for (j, &weight) in self.weights().iter().enumerate() {
+            arcs.push((cover_vertex(j), sink_vertex(j)));
+            arc_weights.push(weight);
+        }
+
+        let target =
+            MinimumWeightAndOrGraph::new(num_target_vertices, arcs, 0, gate_types, arc_weights);
+
+        ReductionVCToAndOrGraph {
+            target,
+            sink_arc_start,
+            num_source_vertices: n,
+        }
+    }
+}
+
+#[cfg(any(test, feature = "example-db"))]
+fn issue_example_source() -> MinimumVertexCover<SimpleGraph, i32> {
+    MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3])
+}
+
+#[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: "minimumvertexcover_to_minimumweightandorgraph",
+        build: || {
+            crate::example_db::specs::rule_example_with_witness::<_, MinimumWeightAndOrGraph>(
+                issue_example_source(),
+                SolutionPair {
+                    source_config: vec![0, 1, 0],
+                    target_config: vec![1, 1, 0, 1, 1, 0, 0, 1, 0],
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/minimumvertexcover_minimumweightandorgraph.rs"]
+mod tests;

src/rules/mod.rs

@@ -93,6 +93,7 @@ pub(crate) mod minimumvertexcover_minimumfeedbackvertexset;
 pub(crate) mod minimumvertexcover_minimumhittingset;
 pub(crate) mod minimumvertexcover_minimummaximalmatching;
 pub(crate) mod minimumvertexcover_minimumsetcovering;
+pub(crate) mod minimumvertexcover_minimumweightandorgraph;
 pub(crate) mod naesatisfiability_maxcut;
 pub(crate) mod naesatisfiability_partitionintoperfectmatchings;
 pub(crate) mod naesatisfiability_setsplitting;
@@ -491,6 +492,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(minimumvertexcover_minimumfeedbackvertexset::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_minimumhittingset::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_minimumsetcovering::canonical_rule_example_specs());
+    specs.extend(minimumvertexcover_minimumweightandorgraph::canonical_rule_example_specs());
     specs.extend(naesatisfiability_setsplitting::canonical_rule_example_specs());
     specs.extend(setsplitting_betweenness::canonical_rule_example_specs());
     specs.extend(satisfiability_integralflowhomologousarcs::canonical_rule_example_specs());

src/unit_tests/rules/minimumvertexcover_minimumweightandorgraph.rs

@@ -0,0 +1,125 @@
+#[cfg(feature = "example-db")]
+use super::canonical_rule_example_specs;
+use super::{issue_example_source, ReductionVCToAndOrGraph};
+use crate::models::graph::MinimumVertexCover;
+use crate::models::misc::MinimumWeightAndOrGraph;
+use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::traits::ReductionResult;
+use crate::rules::ReduceTo;
+#[cfg(feature = "example-db")]
+use crate::solvers::BruteForce;
+use crate::topology::SimpleGraph;
+use crate::traits::Problem;
+use crate::types::Min;
+
+fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i32> {
+    MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![4, 1, 3])
+}
+
+#[test]
+fn test_minimumvertexcover_to_minimumweightandorgraph_closed_loop() {
+    let source = issue_example_source();
+    let reduction: ReductionVCToAndOrGraph =
+        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source);
+
+    assert_optimization_round_trip_from_optimization_target(
+        &source,
+        &reduction,
+        "MVC -> MinimumWeightAndOrGraph closed loop",
+    );
+}
+
+#[test]
+fn test_reduction_structure() {
+    let source = issue_example_source();
+    let reduction: ReductionVCToAndOrGraph =
+        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    assert_eq!(target.num_vertices(), 9);
+    assert_eq!(target.num_arcs(), 9);
+    assert_eq!(target.source(), 0);
+    assert_eq!(
+        target.gate_types(),
+        &[
+            Some(true),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            None,
+            None,
+            None,
+        ]
+    );
+    assert_eq!(
+        target.arcs(),
+        &[
+            (0, 1),
+            (0, 2),
+            (1, 3),
+            (1, 4),
+            (2, 4),
+            (2, 5),
+            (3, 6),
+            (4, 7),
+            (5, 8),
+        ]
+    );
+    assert_eq!(target.arc_weights(), &[1, 1, 1, 1, 1, 1, 1, 1, 1]);
+}
+
+#[test]
+fn test_weighted_vertices_are_charged_on_sink_arcs() {
+    let source = weighted_path_source();
+    let reduction: ReductionVCToAndOrGraph =
+        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    let target_solution = vec![1, 1, 0, 1, 1, 0, 0, 1, 0];
+    assert_eq!(source.evaluate(&[0, 1, 0]), Min(Some(1)));
+    assert_eq!(target.evaluate(&target_solution), Min(Some(5)));
+    assert_eq!(target.arc_weights(), &[1, 1, 1, 1, 1, 1, 4, 1, 3]);
+    assert_eq!(reduction.extract_solution(&target_solution), vec![0, 1, 0]);
+}
+
+#[cfg(feature = "example-db")]
+#[test]
+fn test_canonical_rule_example_spec_builds() {
+    let example = (canonical_rule_example_specs()
+        .into_iter()
+        .find(|spec| spec.id == "minimumvertexcover_to_minimumweightandorgraph")
+        .expect("example spec should be registered")
+        .build)();
+
+    assert_eq!(example.source.problem, "MinimumVertexCover");
+    assert_eq!(example.target.problem, "MinimumWeightAndOrGraph");
+    assert_eq!(example.solutions.len(), 1);
+
+    let source: MinimumVertexCover<SimpleGraph, i32> =
+        serde_json::from_value(example.source.instance.clone())
+            .expect("source example deserializes");
+    let target: MinimumWeightAndOrGraph = serde_json::from_value(example.target.instance.clone())
+        .expect("target example deserializes");
+    let solution = &example.solutions[0];
+
+    assert_eq!(source.evaluate(&solution.source_config), Min(Some(1)));
+    assert_eq!(target.evaluate(&solution.target_config), Min(Some(5)));
+
+    let best_source = BruteForce::new()
+        .find_witness(&source)
+        .expect("source example should have an optimum");
+    let best_target = BruteForce::new()
+        .find_witness(&target)
+        .expect("target example should have an optimum");
+
+    assert_eq!(
+        source.evaluate(&solution.source_config),
+        source.evaluate(&best_source)
+    );
+    assert_eq!(
+        target.evaluate(&solution.target_config),
+        target.evaluate(&best_target)
+    );
+}