Fix nits: MinimumMaximalMatching -> MinimumMatrixDomination (#847)

isPANN · isPANN · commit 5f348a86da44 · 2026-05-27T03:20:42.000+08:00
diff --git a/docs/paper/reductions.typ b/docs/paper/reductions.typ
@@ -14517,7 +14517,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
         *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.
+        *Extraction.* For this fixture the selected 1-entries 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 maps back to an edge dominating set $F_C subset.eq F$ that need not be a matching: for instance, the optimal witness $C = {(0, 3), (0, 4)}$ corresponds to source edges ${(l_0, r_1), (l_0, r_2)}$, which share endpoint $l_0$. In such cases the polynomial-time Yannakakis-Gavril transformation @yannakakis1980 -- implemented in `extract_solution` as a sequence of drop / swap moves on $F_C$ -- converts $F_C$ into a maximal matching of $B$ of the same or smaller size, here e.g. ${(l_0, r_0), (l_1, r_1)}$ or ${(l_0, r_1), (l_1, r_2)}$.
       ]
     }
   ],
@@ -14543,7 +14543,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
   ($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|$.
+  _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$. Arbitrary optimal MMD witnesses may select 1-entries whose corresponding source edges form a connected subgraph (e.g. two edges sharing a left endpoint) rather than a matching; in that case the polynomial-time Yannakakis-Gavril EDS-to-IEDS transformation iteratively resolves each adjacent pair in $F_C$ by either dropping a redundant edge or swapping it for an edge whose new endpoint lies outside the current vertex cover, terminating in $O(|F|^3)$ time. The result is a maximal matching $M^*$ of $B$ with $|M^*| <= |F_C|$, which `extract_solution` returns as the source-side configuration.
 
   _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.
 ]
diff --git a/src/rules/minimummaximalmatching_minimummatrixdomination.rs b/src/rules/minimummaximalmatching_minimummatrixdomination.rs
@@ -16,13 +16,14 @@
 //!
 //! 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
+//! Yannakakis and Gavril (1980) prove that any edge dominating set `D` 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.
+//! (a maximal matching) `M` of the same or smaller size. We implement this
+//! polynomial transformation directly: repeatedly resolve adjacent pairs in
+//! `D` by either dropping a redundant edge (when its endpoint is already
+//! dominated by `D \ {e}`) or swapping it for an edge whose new endpoint lies
+//! outside the current vertex cover. The procedure runs in `O(|F|^3)` worst
+//! case and never enumerates configurations.
 //!
 //! ## Source variant
 //!
@@ -60,51 +61,229 @@ impl ReductionResult for ReductionMMMToMatrixDomination {
     }
 
     /// Extract a maximal matching of the source bipartite graph from a
-    /// matrix-domination witness.
+    /// matrix-domination witness via the Yannakakis-Gavril (1980) polynomial
+    /// EDS-to-IEDS transformation.
     ///
     /// 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.
+    /// edge dominating set (EDS). Arbitrary optimal MMD witnesses may select
+    /// 1-entries whose corresponding source edges form a connected subgraph
+    /// rather than a matching (e.g. two edges sharing a left endpoint), so
+    /// `D` is not in general independent.
+    ///
+    /// The Yannakakis-Gavril transformation (Theorem 1 of @yannakakis1980)
+    /// converts any EDS into an independent EDS (a maximal matching) of the
+    /// same or smaller size by repeatedly applying one of the following
+    /// reductions while `D` contains two adjacent edges `e1 = (u, v)` and
+    /// `e2 = (v, w)`:
+    ///
+    /// - **Drop:** if every edge of `B` incident to `u` is already dominated
+    ///   by `D \ {e1}`, set `D := D \ {e1}` (size strictly decreases).
+    ///   Symmetric for `w` and `e2`.
+    /// - **Swap:** otherwise, some edge `(u, x)` of `B` is currently dominated
+    ///   only by `e1`. This `x` must lie outside `V(D \ {e1})` and is
+    ///   therefore distinct from `w`, so `(u, x)` is not adjacent to `e2`.
+    ///   Replace `e1` with `(u, x)`: `D := (D \ {e1}) \cup {(u, x)}`. Size is
+    ///   preserved and the adjacent pair at `v` is resolved.
+    ///
+    /// Each iteration strictly decreases either `|D|` or the number of
+    /// adjacent pairs, so the loop terminates in `O(|F|^2)` iterations. Each
+    /// iteration scans `O(|F|)` edges to find an adjacent pair, an EDS check,
+    /// and a swap candidate, for a total of `O(|F|^3)` time. The result is a
+    /// matching that is an EDS, i.e. an independent EDS, which is precisely a
+    /// maximal matching.
     fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_source_edges = self.source.graph().num_edges();
+        let graph = self.source.graph();
+        let edges = graph.edges();
+        let num_source_edges = edges.len();
+        let m = graph.left_size();
         let target_ones = self.target.ones();
-        let bound: usize = target_solution
+
+        // Step 1: map selected target 1-entries back to source edge indices.
+        // The reduction places source edge `(l_i, r_j)` (in bipartite-local
+        // form) at matrix cell `(i, m + j)`, which equals the global edge
+        // `(i, m + j)` returned by `Graph::edges()`. Build the lookup from
+        // matrix cell -> source edge index so we are robust to any ordering
+        // discrepancy between `Graph::edges()` and row-major 1-entries.
+        let cell_to_source_edge: std::collections::HashMap<(usize, usize), usize> = edges
+            .iter()
+            .enumerate()
+            .map(|(idx, &(u, v))| {
+                // Source edge endpoints in bipartite global coords are
+                // (left_idx, m + right_idx); matrix cell is (row=left, col=m+right).
+                let (row, col) = if u < m { (u, v) } else { (v, u) };
+                ((row, col), idx)
+            })
+            .collect();
+        let mut d: Vec<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;
+            .filter_map(|(&sel, &cell)| {
+                if sel == 1 {
+                    cell_to_source_edge.get(&cell).copied()
+                } else {
+                    None
                 }
+            })
+            .collect();
+
+        // Step 2: Yannakakis-Gavril EDS -> independent EDS (maximal matching).
+        // Loop invariants: `d` is an EDS of the source graph; each iteration
+        // strictly decreases either |d| or the number of (unordered) pairs of
+        // adjacent edges inside `d`.
+        loop {
+            // Find an adjacent pair (e1_idx, e2_idx) inside `d`, sharing vertex v.
+            let pair = find_adjacent_pair(&d, &edges);
+            let Some((e1_idx, e2_idx, _shared)) = pair else {
+                break; // `d` is a matching; we are done.
+            };
+
+            // Try dropping e1_idx or e2_idx if the remainder is still an EDS.
+            let mut without_e1 = d.clone();
+            without_e1.swap_remove(d.iter().position(|&x| x == e1_idx).unwrap());
+            if is_edge_dominating_set(&without_e1, &edges) {
+                d = without_e1;
+                continue;
+            }
+            let mut without_e2 = d.clone();
+            without_e2.swap_remove(d.iter().position(|&x| x == e2_idx).unwrap());
+            if is_edge_dominating_set(&without_e2, &edges) {
+                d = without_e2;
+                continue;
+            }
+
+            // Neither drop works -> perform a swap on one of e1 or e2.
+            // Choose endpoint not shared with the other edge: for e1=(u, v),
+            // e2=(v, w), the "non-shared" endpoint of e1 is u.
+            let (e1_a, e1_b) = edges[e1_idx];
+            let (e2_a, e2_b) = edges[e2_idx];
+            let shared = if e1_a == e2_a || e1_a == e2_b {
+                e1_a
+            } else {
+                e1_b
+            };
+            let u = if e1_a == shared { e1_b } else { e1_a };
+            let w = if e2_a == shared { e2_b } else { e2_a };
+
+            // Try to swap e1 := (u, x) where x ∉ V(d \ {e1}). The YG proof
+            // guarantees such x exists when neither drop succeeded.
+            if let Some(new_idx) = find_swap_edge(u, e1_idx, &d, &edges) {
+                replace_in(&mut d, e1_idx, new_idx);
+                continue;
+            }
+            // Symmetric swap on e2.
+            if let Some(new_idx) = find_swap_edge(w, e2_idx, &d, &edges) {
+                replace_in(&mut d, e2_idx, new_idx);
+                continue;
+            }
+
+            // YG guarantees that for an EDS at least one of the four moves
+            // above succeeds. Reaching this point implies the input was not
+            // a valid EDS (i.e., not a feasible MMD witness on the constructed
+            // instance), which violates the reduction's precondition.
+            unreachable!(
+                "Yannakakis-Gavril EDS->IEDS transformation could not progress; \
+                 target witness must be a feasible (dominating) MMD configuration"
+            );
+        }
+
+        // Step 3: encode the matching as a binary configuration over source edges.
+        let mut config = vec![0usize; num_source_edges];
+        for &idx in &d {
+            config[idx] = 1;
+        }
+        config
+    }
+}
+
+/// Return `Some((i, j, v))` where `i`, `j` are indices in `d` of two edges that
+/// share vertex `v`, or `None` if all edges in `d` are pairwise independent.
+fn find_adjacent_pair(
+    d: &[usize],
+    edges: &[(usize, usize)],
+) -> Option<(usize, usize, usize)> {
+    for (a_pos, &i) in d.iter().enumerate() {
+        let (iu, iv) = edges[i];
+        for &j in &d[a_pos + 1..] {
+            let (ju, jv) = edges[j];
+            if iu == ju || iu == jv {
+                return Some((i, j, iu));
+            }
+            if iv == ju || iv == jv {
+                return Some((i, j, iv));
             }
         }
+    }
+    None
+}
 
-        // 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]
+/// Check whether the edge set `d` (indices into `edges`) dominates every edge
+/// of `edges`. An edge `f` is dominated iff `f ∈ d` or `f` shares an endpoint
+/// with some edge in `d`.
+fn is_edge_dominating_set(d: &[usize], edges: &[(usize, usize)]) -> bool {
+    // Vertex cover of the candidate EDS.
+    let mut covered_vertices: std::collections::HashSet<usize> =
+        std::collections::HashSet::new();
+    for &i in d {
+        let (u, v) = edges[i];
+        covered_vertices.insert(u);
+        covered_vertices.insert(v);
     }
+    edges.iter().enumerate().all(|(f_idx, (u, v))| {
+        d.contains(&f_idx) || covered_vertices.contains(u) || covered_vertices.contains(v)
+    })
+}
+
+/// Find an edge index in `edges` that is (i) incident to vertex `endpoint`,
+/// (ii) different from `excluded_idx`, and (iii) whose other endpoint lies
+/// outside `V(d \ {excluded_idx})`.
+///
+/// This is the swap candidate `(u, x)` from the Yannakakis-Gavril argument
+/// when the drop move is not available for `excluded_idx`.
+fn find_swap_edge(
+    endpoint: usize,
+    excluded_idx: usize,
+    d: &[usize],
+    edges: &[(usize, usize)],
+) -> Option<usize> {
+    // Vertex cover of d \ {excluded_idx}.
+    let mut other_cover: std::collections::HashSet<usize> = std::collections::HashSet::new();
+    for &i in d {
+        if i == excluded_idx {
+            continue;
+        }
+        let (u, v) = edges[i];
+        other_cover.insert(u);
+        other_cover.insert(v);
+    }
+    for (k, &(u, v)) in edges.iter().enumerate() {
+        if k == excluded_idx {
+            continue;
+        }
+        let (e_endpoint, other) = if u == endpoint {
+            (u, v)
+        } else if v == endpoint {
+            (v, u)
+        } else {
+            continue;
+        };
+        debug_assert_eq!(e_endpoint, endpoint);
+        if !other_cover.contains(&other) {
+            return Some(k);
+        }
+    }
+    None
+}
+
+/// Replace `old_idx` with `new_idx` inside `d` in-place. Panics if `old_idx`
+/// is not present.
+fn replace_in(d: &mut [usize], old_idx: usize, new_idx: usize) {
+    let pos = d
+        .iter()
+        .position(|&x| x == old_idx)
+        .expect("old_idx must be present in d");
+    d[pos] = new_idx;
 }
 
 #[reduction(
diff --git a/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs b/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs
@@ -133,6 +133,57 @@ fn test_no_instance_unreachable_threshold() {
     }
 }
 
+#[test]
+fn test_extract_solution_yg_transform_on_non_matching_eds() {
+    // Verify that the Yannakakis-Gavril EDS->IEDS transformation correctly
+    // handles a target witness whose corresponding source edges form a
+    // *connected* subgraph (two edges sharing l0), not yet a matching.
+    //
+    // On the YES bipartite graph, the EDS {(l0, r1), (l0, r2)} is a size-2
+    // minimum EDS that shares vertex l0. Its image in the matrix is the
+    // 1-entries at indices 1 and 2 (positions (0, 3) and (0, 4)). This
+    // dominates all other 1-entries via row 0 / column 3 / column 4.
+    //
+    // The naive "drop one edge" reduction fails: removing either of
+    // {(l0, r1), (l0, r2)} from D leaves a vertex (l1 or r2/r1) whose
+    // incident edge (l1, r2) is no longer dominated. The transformation
+    // must therefore swap one of the adjacent edges for a different bipartite
+    // edge whose new endpoint lies outside V(D \ {e}). The result is a valid
+    // maximal matching of size <= 2, e.g. {(l0, r0), (l1, r1)} or
+    // {(l0, r1), (l1, r2)}.
+    let source = MinimumMaximalMatching::new(yes_bipartite());
+    let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+
+    // Construct the non-matching EDS witness explicitly. ones() ordering on
+    // this instance is [(0,2),(0,3),(0,4),(1,3),(1,4)]; indices 1 and 2
+    // pick (0,3) = source edge (l0, r1) and (0,4) = source edge (l0, r2).
+    let target_witness = vec![0, 1, 1, 0, 0];
+
+    // Sanity-check: this is actually a feasible MMD witness on the target.
+    let target = reduction.target_problem();
+    assert_eq!(target.evaluate(&target_witness), Min(Some(2)));
+
+    let extracted = reduction.extract_solution(&target_witness);
+
+    // The extracted configuration must be a valid maximal matching of B of
+    // size 2 (= mm(B)). Crucially it cannot be {(l0, r1), (l0, r2)} because
+    // those two source edges share l0 and are not a matching.
+    assert!(
+        source.is_valid_maximal_matching(&extracted),
+        "YG transform must produce a maximal matching, got {extracted:?}"
+    );
+    let size: usize = extracted.iter().sum();
+    assert_eq!(
+        size, 2,
+        "extracted matching must have size mm(B) = 2, got size {size}"
+    );
+    assert!(
+        !(extracted[1] == 1 && extracted[2] == 1),
+        "transform must break the (l0,r1)-(l0,r2) adjacency"
+    );
+    assert_eq!(source.evaluate(&extracted), Min(Some(2)));
+}
+
 #[test]
 fn test_identity_on_random_bipartite_instances() {
     // Verify the Yannakakis-Gavril identity mm(B) = min matrix domination of

Original file line number	Diff line number	Diff line change
`@@ -14517,7 +14517,7 @@ The following reductions to Integer Linear Programming are straightforward formu`
`14517`	`14517`
`14518`	`14518`	`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$.`
`14519`	`14519`
`14520`		`- 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.`
	`14520`	+ Extraction. For this fixture the selected 1-entries 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 maps back to an edge dominating set $F_C subset.eq F$ that need not be a matching: for instance, the optimal witness $C = {(0, 3), (0, 4)}$ corresponds to source edges ${(l_0, r_1), (l_0, r_2)}$, which share endpoint $l_0$. In such cases the polynomial-time Yannakakis-Gavril transformation @yannakakis1980 -- implemented in `extract_solution` as a sequence of drop / swap moves on $F_C$ -- converts $F_C$ into a maximal matching of $B$ of the same or smaller size, here e.g. ${(l_0, r_0), (l_1, r_1)}$ or ${(l_0, r_1), (l_1, r_2)}$.
`14521`	`14521`	`]`
`14522`	`14522`	`}`
`14523`	`14523`	`],`
`@@ -14543,7 +14543,7 @@ The following reductions to Integer Linear Programming are straightforward formu`
`14543`	`14543`
`14544`	`14544`	`($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$.`
`14545`	`14545`
`14546`		`- _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\|$.`
	`14546`	+ _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$. Arbitrary optimal MMD witnesses may select 1-entries whose corresponding source edges form a connected subgraph (e.g. two edges sharing a left endpoint) rather than a matching; in that case the polynomial-time Yannakakis-Gavril EDS-to-IEDS transformation iteratively resolves each adjacent pair in $F_C$ by either dropping a redundant edge or swapping it for an edge whose new endpoint lies outside the current vertex cover, terminating in $O(\|F\|^3)$ time. The result is a maximal matching $M^$ of $B$ with $\|M^\| <= \|F_C\|$, which `extract_solution` returns as the source-side configuration.
`14547`	`14547`
`14548`	`14548`	`_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.`
`14549`	`14549`	`]`