Fix nits: MinimumMaximalMatching -> MaximumAchromaticNumber (#846)

Address three review nits on commit 1826867:

1. Canonical example richness: swap the path P4 canonical example for a
   "T-tree" on 5 vertices (spider v0-v1-v2-v3 with extra leaf v1-v4),
   which exposes two strictly suboptimal maximal matchings besides the
   minimum (mm = 1 vs. two size-2 maximal matchings), comfortably
   passing the >=2-suboptimals rule-of-thumb. Update the canonical
   builder, the paper worked example, and the closed-loop test to match.

2. extract_solution: replace the per-call HashMap rebuild with a single
   pass over source_edges that checks whether each edge's endpoints
   share a color. For bipartite G all color classes have size <= 2,
   so this is equivalent and avoids any auxiliary allocation.

3. Unit test imports: drop the catch-all "use super::*" in favour of an
   explicit "use" list mirroring the MVC->MIS reference test.

cargo test rules::minimummaximalmatching_maximumachromaticnumber: 5
passed (closed-loop, complement structure, known coloring, suboptimal
recovery, identity); make paper builds cleanly.

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

Author: isPANN

docs/paper/reductions.typ

@@ -14429,7 +14429,7 @@ The following reductions to Integer Linear Programming are straightforward formu
   example: true,
   example-source-variant: (graph: "BipartiteGraph"),
   example-target-variant: (graph: "SimpleGraph"),
-  example-caption: [Path $P_4$ as a bipartite graph with $A = {v_0, v_2}$, $B = {v_1, v_3}$.],
+  example-caption: [T-tree on $5$ vertices (spider with three legs at $v_1$): $v_0 - v_1 - v_2 - v_3$ plus the leaf $v_1 - v_4$, encoded as bipartite with $A = {v_0, v_2, v_4}$, $B = {v_1, v_3}$.],
   extra: [
     #{
       let source-edges = mmm_ach.target.instance.graph.edges
@@ -14448,15 +14448,15 @@ The following reductions to Integer Linear Programming are straightforward formu
           "pred evaluate mmm.json --config " + mmm_ach_sol.source_config.map(str).join(","),
         )
 
-        *Step 1 -- Source instance.* Path $P_4$ encoded as a bipartite graph with bipartition $A = {v_0, v_2}$ and $B = {v_1, v_3}$. In unified indices the vertex set is ${0, 1, 2, 3}$ (left vertices first), $n = #n-source$, and the $m = #m-source$ edges are #source-edges.map(e => $(#e.at(0), #e.at(1))$).join(", ").
+        *Step 1 -- Source instance.* The T-tree on $5$ vertices is the spider graph with centre $v_1$ and legs to $v_0$, $v_2$, $v_4$, plus the pendant edge $v_2 - v_3$. It is bipartite with $A = {v_0, v_2, v_4}$ and $B = {v_1, v_3}$. In unified indices the vertex set is ${0, 1, 2, 3, 4}$ (left vertices first, mapping $v_0 mapsto 0$, $v_2 mapsto 1$, $v_4 mapsto 2$, $v_1 mapsto 3$, $v_3 mapsto 4$), so $n = #n-source$ and the $m = #m-source$ edges are #source-edges.map(e => $(#e.at(0), #e.at(1))$).join(", ").
 
-        *Step 2 -- Complement graph $H = overline(G)$.* The non-edges of $G$ in $K_4$ give the target edge set, with $|E(H)| = #m-target$ edges (#mmm_ach.target.instance.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")). The decision threshold transforms as $K' = n - K$.
+        *Step 2 -- Complement graph $H = overline(G)$.* The non-edges of $G$ in $K_5$ give the target edge set, with $|E(H)| = #m-target$ edges (#mmm_ach.target.instance.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")). The decision threshold transforms as $K' = n - K$.
 
-        *Step 3 -- Source optimum.* The minimum maximal matching uses the middle edge, so $"mm"(G) = #matched.len() = 1$ (source index $#matched.at(0)$).
+        *Step 3 -- Source optimum.* The minimum maximal matching uses the central edge $(v_1, v_2)$, so $"mm"(G) = #matched.len() = 1$ (source index $#matched.at(0)$). The T-tree also admits two strictly larger maximal matchings $\{(v_0, v_1), (v_2, v_3)\}$ and $\{(v_1, v_4), (v_2, v_3)\}$, both of size $2$ -- this richness is the reason for choosing the T-tree over the path $P_4$ as the canonical example.
 
         *Step 4 -- Target optimum.* The achromatic coloring stored in the fixture is $#color-of.map(str).join(", ")$. The size-$2$ color class corresponds to the source edge selected in Step 3, and the singletons contribute the remaining $n - 2$ classes, so the achromatic number is $psi(H) = n - "mm"(G) = #n-source - 1 = #(n-source - 1) #sym.checkmark$.
 
-        *Multiplicity:* The fixture stores one canonical witness; other valid achromatic $3$-colorings exist and would extract to other minimum maximal matchings.
+        *Multiplicity:* The fixture stores one canonical witness; other valid achromatic $4$-colorings exist and would extract to the same minimum maximal matching after relabelling colors.
       ]
     }
   ],

src/rules/minimummaximalmatching_maximumachromaticnumber.rs

@@ -11,7 +11,6 @@ use crate::models::graph::{MaximumAchromaticNumber, MinimumMaximalMatching};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{BipartiteGraph, Graph, SimpleGraph};
-use std::collections::HashMap;
 
 /// Result of reducing `MinimumMaximalMatching<BipartiteGraph>` to
 /// `MaximumAchromaticNumber<SimpleGraph>`.
@@ -38,39 +37,16 @@ impl ReductionResult for ReductionMMMToAchromatic {
     /// Extract a maximal matching of the source graph from an achromatic
     /// coloring of `complement(G)`.
     ///
-    /// Each color class of size exactly 2 corresponds to a clique-in-G of
-    /// size 2, i.e., a single source edge. Marking those edges yields the
-    /// maximal matching `M` with `|M| = |V| - k`, where `k` is the number of
-    /// colors used.
+    /// Each color class of size exactly 2 in `complement(G)` is an independent
+    /// set there and thus a clique in `G`. For bipartite `G` such a clique has
+    /// size 2, i.e., a source edge. A source edge `(u, v)` belongs to the
+    /// extracted matching iff `u` and `v` share a color, which we detect in a
+    /// single pass over `source_edges`.
     fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_source_edges = self.source_edges.len();
-        let mut source_config = vec![0usize; num_source_edges];
-
-        // Group vertices by color.
-        let mut color_to_vertices: HashMap<usize, Vec<usize>> = HashMap::new();
-        for (vertex, &color) in target_solution.iter().enumerate() {
-            color_to_vertices.entry(color).or_default().push(vertex);
-        }
-
-        // Build an edge lookup keyed by canonical (min, max) pairs.
-        let mut edge_index: HashMap<(usize, usize), usize> = HashMap::new();
-        for (idx, &(u, v)) in self.source_edges.iter().enumerate() {
-            let key = if u < v { (u, v) } else { (v, u) };
-            edge_index.insert(key, idx);
-        }
-
-        // Color classes of size 2 must be edges of G (cliques in G of size 2).
-        for vertices in color_to_vertices.values() {
-            if vertices.len() == 2 {
-                let (a, b) = (vertices[0], vertices[1]);
-                let key = if a < b { (a, b) } else { (b, a) };
-                if let Some(&idx) = edge_index.get(&key) {
-                    source_config[idx] = 1;
-                }
-            }
-        }
-
-        source_config
+        self.source_edges
+            .iter()
+            .map(|&(u, v)| usize::from(target_solution[u] == target_solution[v]))
+            .collect()
     }
 }
 
@@ -119,50 +95,63 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "minimummaximalmatching_to_maximumachromaticnumber",
         build: || {
-            // Path P4 as a bipartite graph: A = {v0, v2}, B = {v1, v3}.
+            // "T" tree (spider with three legs at the centre v1):
+            //   v0 -- v1 -- v2 -- v3
+            //         |
+            //         v4
             //
-            // BipartiteGraph encoding (left_size = 2, right_size = 2):
-            //   left  local 0 -> v0, local 1 -> v2
+            // Five vertices and four edges. Bipartite with
+            // A = {v0, v2, v4} and B = {v1, v3}.
+            //
+            // BipartiteGraph encoding (left_size = 3, right_size = 2):
+            //   left  local 0 -> v0, local 1 -> v2, local 2 -> v4
             //   right local 0 -> v1, local 1 -> v3
             //   edges (left_idx, right_idx):
             //     (v0, v1) -> (0, 0)
-            //     (v1, v2) -> (1, 0)   (v2 is left=1, v1 is right=0)
+            //     (v1, v2) -> (1, 0)
             //     (v2, v3) -> (1, 1)
+            //     (v1, v4) -> (2, 0)
             //
             // Unified vertex labels:
-            //   0 = v0 (left 0)
-            //   1 = v2 (left 1)
-            //   2 = v1 (right 0)
-            //   3 = v3 (right 1)
+            //   0 = v0 (left 0), 1 = v2 (left 1), 2 = v4 (left 2),
+            //   3 = v1 (right 0), 4 = v3 (right 1).
+            //
+            // Unified edges from Graph::edges() (in source order):
+            //   (0, 3), (1, 3), (1, 4), (2, 3).
             //
-            // Unified edges from Graph::edges():
-            //   (0, 2), (1, 2), (1, 3)
+            // Maximal matchings of G:
+            //   - {(v1, v2)}                 size 1   <-- mm(G) = 1
+            //   - {(v0, v1), (v2, v3)}       size 2   (suboptimal 1)
+            //   - {(v1, v4), (v2, v3)}       size 2   (suboptimal 2)
+            // So the canonical example exhibits >=2 suboptimal maximal
+            // matchings besides the optimum.
             //
-            // mm(G) = 1, achieved by selecting the middle edge (v1, v2),
-            // which is unified edge index 1 (i.e., (1, 2)).
-            // So source_config = [0, 1, 0].
+            // Canonical optimum: pick the central edge (v1, v2), which is
+            // source edge index 1. source_config = [0, 1, 0, 0].
             //
-            // complement(G) edges: (0, 1), (0, 3), (2, 3).
+            // complement(G) on K_5: 10 - 4 = 6 edges, namely
+            //   (0, 1), (0, 2), (0, 4), (1, 2), (2, 4), (3, 4).
             //
-            // Achromatic 3-coloring of complement(G):
-            //   v0 (idx 0)  -> color 0
-            //   v2 (idx 1)  -> color 1
-            //   v1 (idx 2)  -> color 1   (paired with v2 = G-edge (v1, v2))
-            //   v3 (idx 3)  -> color 2
-            // target_config = [0, 1, 1, 2].
+            // Canonical achromatic 4-coloring of complement(G):
+            //   v0 (idx 0) -> color 1
+            //   v2 (idx 1) -> color 0  (paired with v1 = G-edge (v1, v2))
+            //   v4 (idx 2) -> color 3
+            //   v1 (idx 3) -> color 0
+            //   v3 (idx 4) -> color 2
+            // target_config = [1, 0, 3, 0, 2]; psi(H) = |V| - mm(G) = 4.
             let source = MinimumMaximalMatching::new(BipartiteGraph::new(
+                3,
                 2,
-                2,
-                vec![(0, 0), (1, 0), (1, 1)],
+                vec![(0, 0), (1, 0), (1, 1), (2, 0)],
             ));
             crate::example_db::specs::rule_example_with_witness::<
                 _,
                 MaximumAchromaticNumber<SimpleGraph>,
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 0],
-                    target_config: vec![0, 1, 1, 2],
+                    source_config: vec![0, 1, 0, 0],
+                    target_config: vec![1, 0, 3, 0, 2],
                 },
             )
         },

src/unit_tests/rules/minimummaximalmatching_maximumachromaticnumber.rs

@@ -1,44 +1,49 @@
-use super::*;
+use crate::models::graph::{MaximumAchromaticNumber, MinimumMaximalMatching};
+use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::solvers::{BruteForce, Solver};
+use crate::topology::{BipartiteGraph, Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, Min};
 
-/// Build the canonical issue example: path P4 represented as a bipartite graph
-/// with bipartition A = {v0, v2}, B = {v1, v3} and edges (v0,v1), (v1,v2),
-/// (v2,v3). See the canonical builder for the unified-index encoding.
-fn p4_bipartite() -> BipartiteGraph {
-    // left_size = 2 (A), right_size = 2 (B)
+/// Build the canonical T-tree example: spider with three legs at the centre
+/// v1, namely v0--v1--v2--v3 with an extra leaf v1--v4. The bipartition is
+/// A = {v0, v2, v4}, B = {v1, v3}. See the canonical builder for the full
+/// unified-index encoding.
+fn t_tree_bipartite() -> BipartiteGraph {
+    // left_size = 3 (A), right_size = 2 (B)
     // edges in (left_idx, right_idx) form:
     //   (v0, v1) -> (0, 0)
     //   (v1, v2) -> (1, 0)
     //   (v2, v3) -> (1, 1)
-    BipartiteGraph::new(2, 2, vec![(0, 0), (1, 0), (1, 1)])
+    //   (v1, v4) -> (2, 0)
+    BipartiteGraph::new(3, 2, vec![(0, 0), (1, 0), (1, 1), (2, 0)])
 }
 
 #[test]
 fn test_minimummaximalmatching_to_maximumachromaticnumber_closed_loop() {
-    let source = MinimumMaximalMatching::new(p4_bipartite());
+    let source = MinimumMaximalMatching::new(t_tree_bipartite());
     let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
     let target = reduction.target_problem();
 
-    // |V| = 4, |E(G)| = 3, so |E(H)| = C(4,2) - 3 = 6 - 3 = 3
-    assert_eq!(target.num_vertices(), 4);
-    assert_eq!(target.num_edges(), 3);
+    // |V| = 5, |E(G)| = 4, so |E(H)| = C(5,2) - 4 = 10 - 4 = 6
+    assert_eq!(target.num_vertices(), 5);
+    assert_eq!(target.num_edges(), 6);
 
     let solver = BruteForce::new();
 
-    // Source MMM(P4) = 1 (the single middle edge is the minimum maximal matching).
+    // Source MMM(T-tree) = 1 (the central edge (v1, v2) is a minimum maximal
+    // matching on its own).
     assert_eq!(solver.solve(&source), Min(Some(1)));
 
-    // Target achromatic number of complement(P4) = |V| - mm(G) = 4 - 1 = 3.
-    assert_eq!(solver.solve(target), Max(Some(3)));
+    // Target achromatic number of complement(G) = |V| - mm(G) = 5 - 1 = 4.
+    assert_eq!(solver.solve(target), Max(Some(4)));
 
     // Closed-loop: every optimal target witness extracts to a valid maximal
     // matching with size mm(G).
     let target_witnesses = solver.find_all_witnesses(target);
     assert!(
         !target_witnesses.is_empty(),
-        "complement(P4) must admit an achromatic 3-coloring"
+        "complement(T-tree) must admit an achromatic 4-coloring"
     );
     for witness in &target_witnesses {
         let extracted = reduction.extract_solution(witness);
@@ -52,51 +57,60 @@ fn test_minimummaximalmatching_to_maximumachromaticnumber_closed_loop() {
 
 #[test]
 fn test_target_complement_structure() {
-    let source = MinimumMaximalMatching::new(p4_bipartite());
+    let source = MinimumMaximalMatching::new(t_tree_bipartite());
     let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
     let target = reduction.target_problem();
 
-    // Source unified edges: (0,2), (1,2), (1,3).
-    // Complement edges in K_4 minus source: (0,1), (0,3), (2,3).
+    // Source unified edges: (0,3), (1,3), (1,4), (2,3).
+    // Complement edges in K_5 minus source: (0,1), (0,2), (0,4), (1,2), (2,4), (3,4).
     let mut target_edges = target.graph().edges();
     target_edges.sort();
-    assert_eq!(target_edges, vec![(0, 1), (0, 3), (2, 3)]);
+    assert_eq!(
+        target_edges,
+        vec![(0, 1), (0, 2), (0, 4), (1, 2), (2, 4), (3, 4)]
+    );
 }
 
 #[test]
 fn test_extract_solution_known_coloring() {
-    let source = MinimumMaximalMatching::new(p4_bipartite());
+    let source = MinimumMaximalMatching::new(t_tree_bipartite());
     let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
 
-    // Coloring v0=0, v2=1, v1=1, v3=2 (unified order: v0,v2,v1,v3).
-    // Size-2 class {1, 2} = {v2, v1}, which is the G-edge (v1, v2) =
-    // unified edge (1, 2), source-edge index 1 in our edges list.
-    let coloring = vec![0, 1, 1, 2];
+    // Canonical 4-coloring of complement(G) (unified order v0,v2,v4,v1,v3):
+    //   v0 -> 1, v2 -> 0, v4 -> 3, v1 -> 0, v3 -> 2.
+    // The single size-2 class {v2, v1} is the G-edge (v1, v2) =
+    // unified edge (1, 3), source-edge index 1 in the edges list.
+    let coloring = vec![1, 0, 3, 0, 2];
     let extracted = reduction.extract_solution(&coloring);
-    assert_eq!(extracted, vec![0, 1, 0]);
+    assert_eq!(extracted, vec![0, 1, 0, 0]);
     assert_eq!(source.evaluate(&extracted), Min(Some(1)));
 }
 
 #[test]
-fn test_no_instance_higher_k_unreachable() {
-    // For source K = 0, the source decision is NO because mm(P4) = 1 > 0.
-    // The reduction sets K' = |V| - K = 4. The target asks for achromatic >= 4.
-    // complement(P4) on 4 vertices admits at most achromatic number 3, so the
-    // target decision is also NO (no 4-coloring is both proper and complete).
-    let source = MinimumMaximalMatching::new(p4_bipartite());
+fn test_extract_solution_recovers_suboptimal_matchings() {
+    // The T-tree exposes >=2 suboptimal maximal matchings besides the
+    // optimum, exactly the situation that motivated the richer canonical
+    // example. We feed the achromatic colorings induced by these size-2
+    // maximal matchings and check the extractor recovers each one.
+    let source = MinimumMaximalMatching::new(t_tree_bipartite());
     let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
-    let target = reduction.target_problem();
 
-    let solver = BruteForce::new();
-    let target_value = solver.solve(target);
-
-    // Achromatic value is exactly 3 on this complement (verified above), so
-    // the threshold 4 is unreachable.
-    if let Max(Some(value)) = target_value {
-        assert!(value < 4, "complement(P4) cannot reach achromatic = 4");
-    } else {
-        panic!("target must have some achromatic number");
-    }
+    // Unified labels: v0=0, v2=1, v4=2, v1=3, v3=4.
+    // Suboptimal matching {(v0,v1), (v2,v3)} -> color v0,v1 the same and
+    // v2,v3 the same; v4 takes a third color.
+    // Source edges in unified order: (0,3), (1,3), (1,4), (2,3).
+    // Edge 0 = (v0, v1) selected; edge 2 = (v2, v3) selected.
+    let coloring_a = vec![0, 1, 2, 0, 1];
+    let extracted_a = reduction.extract_solution(&coloring_a);
+    assert_eq!(extracted_a, vec![1, 0, 1, 0]);
+    assert_eq!(source.evaluate(&extracted_a), Min(Some(2)));
+
+    // Suboptimal matching {(v1, v4), (v2, v3)} -> pair v1 with v4 and v2
+    // with v3; v0 takes a singleton color. Edge 2 = (v2, v3); edge 3 = (v1, v4).
+    let coloring_b = vec![2, 0, 1, 1, 0];
+    let extracted_b = reduction.extract_solution(&coloring_b);
+    assert_eq!(extracted_b, vec![0, 0, 1, 1]);
+    assert_eq!(source.evaluate(&extracted_b), Min(Some(2)));
 }
 
 #[test]
@@ -108,11 +122,11 @@ fn test_identity_on_random_bipartite_instances() {
     // Small library of bipartite graphs:
     //  - K_{2,2} (4-cycle viewed as bipartite, left=2, right=2)
     //  - K_{1,3} (claw / star), and
-    //  - the canonical P4 above.
+    //  - the canonical T-tree above.
     let instances = vec![
         BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1), (1, 0), (1, 1)]),
         BipartiteGraph::new(1, 3, vec![(0, 0), (0, 1), (0, 2)]),
-        p4_bipartite(),
+        t_tree_bipartite(),
     ];
 
     for graph in instances {