Add rule: MinimumMaximalMatching -> MinimumMatrixDomination (#847)

isPANN · isPANN · commit 8a747ea754f5 · 2026-05-27T00:50:24.000+08:00
diff --git a/docs/paper/reductions.typ b/docs/paper/reductions.typ
@@ -14480,6 +14480,74 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Solution extraction._ Group target vertices by color. Every class of size $2$ identifies a source edge in $E$; mark those edges as selected (and leave all others unselected) to obtain a maximal matching $M$ of $G$ with $|M| = |V| - k$.
 ]
 
+#let mmm_mmd = load-example("MinimumMaximalMatching", "MinimumMatrixDomination")
+#let mmm_mmd_sol = mmm_mmd.solutions.at(0)
+#reduction-rule("MinimumMaximalMatching", "MinimumMatrixDomination",
+  example: true,
+  example-source-variant: (graph: "BipartiteGraph"),
+  example-caption: [Bipartite graph $B$ with $L = {l_0, l_1}$, $R = {r_0, r_1, r_2}$, and $|F| = 5$ edges.],
+  extra: [
+    #{
+      let m-left = mmm_mmd.source.instance.graph.left_size
+      let n-right = mmm_mmd.source.instance.graph.right_size
+      let local-edges = mmm_mmd.source.instance.graph.edges
+      let ones = mmm_mmd.target.instance.ones
+      let big-n = mmm_mmd.target.instance.matrix.len()
+      let s-cfg = mmm_mmd_sol.source_config
+      let t-cfg = mmm_mmd_sol.target_config
+      let matched-source = s-cfg.enumerate()
+        .filter(((i, x)) => x == 1)
+        .map(((i, _)) => i)
+      let selected-target = t-cfg.enumerate()
+        .filter(((i, x)) => x == 1)
+        .map(((i, _)) => i)
+      [
+        #pred-commands(
+          "pred create --example " + problem-spec(mmm_mmd.source) + " -o mmm.json",
+          "pred reduce mmm.json --to " + target-spec(mmm_mmd) + " -o bundle.json",
+          "pred solve bundle.json",
+          "pred evaluate mmm.json --config " + s-cfg.map(str).join(","),
+        )
+
+        *Step 1 -- Source instance.* Bipartite graph $B$ with $|L| = #m-left$, $|R| = #n-right$ and $#local-edges.len()$ bipartite-local edges #local-edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The decision threshold is $K = 2$.
+
+        *Step 2 -- Embedded matrix.* The constructed instance is the $#big-n times #big-n$ binary matrix $M$ whose upper-right $#m-left times #n-right$ block holds the biadjacency matrix $B^*$. Its $#ones.len()$ 1-entries lie at positions #ones.map(p => $(#p.at(0), #p.at(1))$).join(", "), and $M$ is upper triangular (all 1-entries above the row-block boundary).
+
+        *Step 3 -- Source optimum.* A minimum maximal matching $M^* = {(l_0, r_0), (l_1, r_1)}$ uses source edge indices #matched-source.map(i => str(i)).join(", "), giving $"mm"(B) = #matched-source.len() = 2$.
+
+        *Step 4 -- Target optimum.* The fixture selects the matrix-domination set $C = {(0, 2), (1, 3)}$ at 1-entry indices #selected-target.map(i => str(i)).join(", "). Every other 1-entry of $M$ shares row $0$ or row $1$ with one of the chosen entries, so $C$ is dominating with $|C| = #selected-target.len() = 2 = "mm"(B) #sym.checkmark$.
+
+        *Extraction.* The selected 1-entries here happen to be pairwise independent (no shared row or column), so they already correspond to a matching of $B$. In general a matrix-domination witness only yields an edge dominating set, and the Yannakakis-Gavril transformation @yannakakis1980 converts it to a maximal matching of equal size.
+      ]
+    }
+  ],
+)[
+  This $O(n^2)$ reduction @yannakakis1980 takes a bipartite source $B = (L, R, F)$ with $|L| = m$ and $|R| = n$, builds the $N times N$ binary matrix $M$ on $N = m + n$ rows and columns whose upper-right $m times n$ block is the biadjacency matrix $B^*$ and whose other entries are zero, and leaves the decision threshold unchanged. The resulting matrix has exactly $|F|$ 1-entries and is upper triangular.
+][
+  _Construction._ Given a Minimum Maximal Matching instance $(B = (L, R, F), K)$ with $B$ bipartite, label the vertices so that $L = {l_0, dots, l_(m-1)}$ corresponds to rows $0, dots, m-1$ of $M$ and $R = {r_0, dots, r_(n-1)}$ corresponds to columns $m, dots, m+n-1$. Define
+  $
+    M_(i,j) = cases(
+      1 quad &"if " i < m " and " j >= m " and " (l_i, r_(j-m)) in F,
+      0 quad &"otherwise",
+    )
+  $
+  and set $K' = K$. Output the Minimum Matrix Domination instance $(M, K')$.
+
+  _Correctness._ The reduction proves the identity $"md"(M) = "mm"(B)$, where $"md"$ denotes the minimum matrix-domination size and $"mm"$ the minimum maximal-matching size.
+
+  Each 1-entry of $M$ lies in the upper-right block and therefore corresponds bijectively to a source edge: $(i, m + j) <-> (l_i, r_j) in F$. Two 1-entries share a row iff their source edges share a left endpoint; they share a column iff their source edges share a right endpoint. Hence a set $C$ of 1-entries dominates $M$ iff the corresponding edges $F_C subset.eq F$ form an edge dominating set (EDS) of $B$.
+
+  Yannakakis and Gavril @yannakakis1980 prove that for every graph the minimum EDS size equals the minimum independent EDS size, and an independent EDS is exactly a maximal matching. Combining these facts:
+
+  ($arrow.r.double$) A maximal matching $M^*$ of $B$ with $|M^*| <= K$ is in particular an EDS, so its image in $M$ is a dominating set of size $<= K = K'$.
+
+  ($arrow.l.double$) A dominating set $C$ of $M$ with $|C| <= K'$ corresponds to an EDS $F_C$ of size $|C| <= K' = K$. Applying the polynomial-time Yannakakis-Gavril transformation to $F_C$ yields a maximal matching of $B$ of the same size, so $"mm"(B) <= K$.
+
+  _Solution extraction._ Read the selected 1-entries of the matrix-domination witness, map each $(i, m + j)$ back to the bipartite edge $(l_i, r_j)$ to obtain an EDS $F_C$ of $B$, and apply the Yannakakis-Gavril EDS-to-maximal-matching conversion to recover a maximal matching $M^*$ with $|M^*| = |F_C|$.
+
+  _Note on source variant._ The reduction crucially requires the source graph to be bipartite. The biadjacency matrix faithfully represents the edge structure of $B$ (each edge contributes exactly one 1-entry). The adjacency matrix of a general undirected graph would produce two symmetric 1-entries per edge that do not preserve the row/column sharing pattern.
+]
+
 #reduction-rule("MinimumMaximalMatching", "ILP")[
   Each edge is either selected or not; matching and maximality constraints are both directly linear in binary edge indicators.
 ][
diff --git a/src/rules/minimummaximalmatching_minimummatrixdomination.rs b/src/rules/minimummaximalmatching_minimummatrixdomination.rs
@@ -0,0 +1,197 @@
+//! Reduction from MinimumMaximalMatching (on a bipartite graph) to
+//! MinimumMatrixDomination.
+//!
+//! Classical reduction of Yannakakis and Gavril (1980) establishing
+//! NP-completeness of MATRIX DOMINATION (Garey & Johnson MS12). For a bipartite
+//! graph `B = (L, R, F)` with `|L| = m` and `|R| = n`, construct the `N x N`
+//! binary matrix `M` (with `N = m + n`) whose upper-right `m x n` block is the
+//! biadjacency matrix `B*` of `B` and whose remaining entries are zero. The
+//! 1-entries of `M` are in bijection with the edges of `B`, and two 1-entries
+//! share a row or column iff the corresponding edges share an endpoint. Hence a
+//! dominating set of 1-entries in `M` corresponds to an edge dominating set of
+//! `B`, and by Yannakakis and Gavril (1980), the minimum edge dominating set
+//! size equals the minimum maximal matching size.
+//!
+//! ## Witness extraction
+//!
+//! Solving Minimum Matrix Domination on the constructed instance yields a
+//! minimum edge dominating set of `B`, which is in general NOT a matching.
+//! Yannakakis and Gavril (1980) prove that any edge dominating set can be
+//! transformed in polynomial time into an independent edge dominating set
+//! (a maximal matching) of the same size. We implement this conversion by a
+//! direct search: enumerate maximal matchings of `B` and return one of size at
+//! most `|EDS|`. Because every minimum maximal matching is also an EDS and the
+//! two minima are equal, such a matching always exists when the target witness
+//! is optimal.
+//!
+//! ## Source variant
+//!
+//! The reduction requires the bipartite (`BipartiteGraph`) variant of
+//! `MinimumMaximalMatching`. The biadjacency matrix faithfully represents the
+//! edge structure of a bipartite graph (each edge -> exactly one 1-entry),
+//! whereas an undirected adjacency matrix would produce two symmetric 1-entries
+//! per edge that do not preserve the row/column sharing pattern.
+
+use crate::models::algebraic::MinimumMatrixDomination;
+use crate::models::graph::MinimumMaximalMatching;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::topology::{BipartiteGraph, Graph};
+
+/// Result of reducing `MinimumMaximalMatching<BipartiteGraph>` to
+/// `MinimumMatrixDomination`.
+///
+/// Holds the constructed target matrix-domination instance together with a copy
+/// of the source bipartite-matching problem. The source copy is used by
+/// `extract_solution` to perform the Yannakakis-Gavril conversion from an edge
+/// dominating set to an equally-sized maximal matching.
+#[derive(Debug, Clone)]
+pub struct ReductionMMMToMatrixDomination {
+    target: MinimumMatrixDomination,
+    source: MinimumMaximalMatching<BipartiteGraph>,
+}
+
+impl ReductionResult for ReductionMMMToMatrixDomination {
+    type Source = MinimumMaximalMatching<BipartiteGraph>;
+    type Target = MinimumMatrixDomination;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    /// Extract a maximal matching of the source bipartite graph from a
+    /// matrix-domination witness.
+    ///
+    /// The target witness identifies a set of 1-entries of `M`. Each selected
+    /// 1-entry in the upper-right block `B*` corresponds bijectively to a
+    /// source edge, so the selection induces an edge set `D` of `B` that is an
+    /// edge dominating set. The minimum edge dominating set size of a graph
+    /// equals the minimum maximal matching size [Yannakakis-Gavril 1980], so
+    /// any optimal target witness yields `|D|` equal to `mm(B)`. We then
+    /// recover a maximal matching `M` of `B` with `|M| <= |D|` by enumerating
+    /// candidate source configurations.
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        let num_source_edges = self.source.graph().num_edges();
+        let target_ones = self.target.ones();
+        let bound: usize = target_solution
+            .iter()
+            .zip(target_ones.iter())
+            .filter(|(&sel, _)| sel == 1)
+            .count();
+
+        // Search for any maximal matching of B with cardinality at most `bound`.
+        // For an optimal target witness, |D| = mm(B), so such a matching
+        // exists by Yannakakis-Gavril (1980). For canonical example sizes this
+        // enumeration is fast; in the worst case it is 2^|E| which mirrors the
+        // brute-force solve used elsewhere in the test infrastructure.
+        //
+        // Iterate by size from 0 upward so we always return a smallest-known
+        // maximal matching.
+        for target_size in 0..=bound {
+            for mask in 0u64..(1u64 << num_source_edges) {
+                if mask.count_ones() as usize != target_size {
+                    continue;
+                }
+                let config: Vec<usize> = (0..num_source_edges)
+                    .map(|i| ((mask >> i) & 1) as usize)
+                    .collect();
+                if self.source.is_valid_maximal_matching(&config) {
+                    return config;
+                }
+            }
+        }
+
+        // Fallback: a zero configuration. This branch is unreachable when the
+        // reduction is correct and the supplied target witness is feasible.
+        vec![0; num_source_edges]
+    }
+}
+
+#[reduction(
+    overhead = {
+        num_rows = "num_vertices",
+        num_cols = "num_vertices",
+        num_ones = "num_edges",
+    }
+)]
+impl ReduceTo<MinimumMatrixDomination> for MinimumMaximalMatching<BipartiteGraph> {
+    type Result = ReductionMMMToMatrixDomination;
+
+    fn reduce_to(&self) -> Self::Result {
+        let g = self.graph();
+        let m = g.left_size();
+        let n = g.right_size();
+        let big_n = m + n;
+
+        // Build the N x N matrix:
+        //   upper-right m x n block = biadjacency matrix B*
+        //   all other entries = 0
+        // The matrix is upper triangular: 1-entries lie strictly in rows
+        // 0..m and columns m..m+n.
+        let mut matrix = vec![vec![false; big_n]; big_n];
+        for &(left_idx, right_idx) in g.left_edges() {
+            // Row = l_left_idx (in 0..m), Column = m + right_idx (in m..m+n).
+            matrix[left_idx][m + right_idx] = true;
+        }
+
+        let target = MinimumMatrixDomination::new(matrix);
+
+        ReductionMMMToMatrixDomination {
+            target,
+            source: self.clone(),
+        }
+    }
+}
+
+#[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: "minimummaximalmatching_to_minimummatrixdomination",
+        build: || {
+            // Canonical YES instance from the issue.
+            //
+            // Bipartite graph B with L = {l0, l1}, R = {r0, r1, r2} and edges
+            // F = {(l0, r0), (l0, r1), (l0, r2), (l1, r1), (l1, r2)}.
+            //
+            // Source edge indices (in BipartiteGraph::edges() order):
+            //   0: (l0, r0) = (0, 0)
+            //   1: (l0, r1) = (0, 1)
+            //   2: (l0, r2) = (0, 2)
+            //   3: (l1, r1) = (1, 1)
+            //   4: (l1, r2) = (1, 2)
+            //
+            // mm(B) = 2; one optimum is M = {(l0, r0), (l1, r1)} ->
+            // source_config = [1, 0, 0, 1, 0].
+            //
+            // Constructed N x N matrix with N = 5; 1-entries in row-major
+            // order (matching the source edge order above):
+            //   idx 0: (0, 2)  <- (l0, r0)
+            //   idx 1: (0, 3)  <- (l0, r1)
+            //   idx 2: (0, 4)  <- (l0, r2)
+            //   idx 3: (1, 3)  <- (l1, r1)
+            //   idx 4: (1, 4)  <- (l1, r2)
+            //
+            // Selecting target_config = [1, 0, 0, 1, 0] picks 1-entries
+            // {(0, 2), (1, 3)}, which together dominate every other 1-entry by
+            // shared row 0 or row 1.
+            let source = MinimumMaximalMatching::new(BipartiteGraph::new(
+                2,
+                3,
+                vec![(0, 0), (0, 1), (0, 2), (1, 1), (1, 2)],
+            ));
+            crate::example_db::specs::rule_example_with_witness::<_, MinimumMatrixDomination>(
+                source,
+                SolutionPair {
+                    source_config: vec![1, 0, 0, 1, 0],
+                    target_config: vec![1, 0, 0, 1, 0],
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs"]
+mod tests;
diff --git a/src/rules/mod.rs b/src/rules/mod.rs
@@ -89,6 +89,7 @@ pub(crate) mod minimumdiscreteplanarinversekinematics_qubo;
 pub(crate) mod minimumfeedbackarcset_maximumlikelihoodranking;
 pub(crate) mod minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters;
 pub(crate) mod minimummaximalmatching_maximumachromaticnumber;
+pub(crate) mod minimummaximalmatching_minimummatrixdomination;
 pub(crate) mod minimummultiwaycut_qubo;
 pub(crate) mod minimumvertexcover_comparativecontainment;
 pub(crate) mod minimumvertexcover_ensemblecomputation;
@@ -508,6 +509,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(minimumvertexcover_longestcommonsubsequence::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_maximumindependentset::canonical_rule_example_specs());
     specs.extend(minimummaximalmatching_maximumachromaticnumber::canonical_rule_example_specs());
+    specs.extend(minimummaximalmatching_minimummatrixdomination::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_minimummaximalmatching::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_minimumfeedbackarcset::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_minimumfeedbackvertexset::canonical_rule_example_specs());
diff --git a/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs b/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs
