Fix #164: MaximumClique to MaximumIndependentSet reduction (#604)

* feat: add MaximumClique to MaximumIndependentSet reduction (#164)

Implement complement graph reduction (Karp 1972): a clique in G
corresponds to an independent set in the complement graph.

- Reduction rule with overhead: n vertices, n(n-1)/2 - m edges
- 5 unit tests including closed-loop, triangle, empty graph, weights
- Example program with JSON export
- Paper entry with proof and worked example

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

* Regenerate reduction_graph.json after merge

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

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: GiggleLiu <cacate0129@gmail.com>

Author: 3 people

docs/paper/reductions.typ

@@ -1674,6 +1674,19 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Solution extraction._ $K = {v : x_v = 1}$.
 ]
 
+#reduction-rule("MaximumClique", "MaximumIndependentSet",
+  example: true,
+  example-caption: [Path graph $P_4$: clique in $G$ maps to independent set in complement $overline(G)$.],
+)[
+  A clique in $G$ is an independent set in the complement graph $overline(G)$, where $overline(G) = (V, overline(E))$ with $overline(E) = {(u,v) : u != v, (u,v) in.not E}$. This classical reduction @karp1972 preserves vertices and weights; only the edge set changes.
+][
+  _Construction._ Given MaximumClique instance $(G = (V, E), bold(w))$ with $n = |V|$ and $m = |E|$, create MaximumIndependentSet instance $(overline(G) = (V, overline(E)), bold(w))$ where $overline(E) = {(u,v) : u != v, (u,v) in.not E}$. The complement graph has $n(n-1)/2 - m$ edges. Weights are preserved identically.
+
+  _Correctness._ ($arrow.r.double$) If $S$ is a clique in $G$, then all pairs in $S$ are adjacent in $G$, so no pair in $S$ is adjacent in $overline(G)$, making $S$ an independent set in $overline(G)$. ($arrow.l.double$) If $S$ is an independent set in $overline(G)$, then no pair in $S$ is adjacent in $overline(G)$, so all pairs in $S$ are adjacent in $G$, making $S$ a clique. Since both problems maximize $sum_(v in S) w_v$, optimal values coincide.
+
+  _Solution extraction._ Identity: the configuration is the same in both problems, since vertices are preserved one-to-one.
+]
+
 #reduction-rule("BinPacking", "ILP")[
   The assignment-based formulation introduces a binary indicator for each item--bin pair and a binary variable for each bin being open. Assignment constraints ensure each item is placed in exactly one bin; capacity constraints link bin usage to item weights.
 ][

docs/src/reductions/reduction_graph.json

@@ -412,6 +412,21 @@
     }
   ],
   "edges": [
+    {
+      "source": 3,
+      "target": 9,
+      "overhead": [
+        {
+          "field": "num_vars",
+          "formula": "num_items * num_items + num_items"
+        },
+        {
+          "field": "num_constraints",
+          "formula": "2 * num_items"
+        }
+      ],
+      "doc_path": "rules/binpacking_ilp/index.html"
+    },
     {
       "source": 4,
       "target": 9,
@@ -651,6 +666,21 @@
       ],
       "doc_path": "rules/maximumclique_ilp/index.html"
     },
+    {
+      "source": 22,
+      "target": 26,
+      "overhead": [
+        {
+          "field": "num_vertices",
+          "formula": "num_vertices"
+        },
+        {
+          "field": "num_edges",
+          "formula": "num_vertices * (num_vertices + -1 * 1) * 2^-1 + -1 * num_edges"
+        }
+      ],
+      "doc_path": "rules/maximumclique_maximumindependentset/index.html"
+    },
     {
       "source": 23,
       "target": 24,

examples/reduction_maximumclique_to_maximumindependentset.rs

@@ -0,0 +1,114 @@
+// # Maximum Clique to Maximum Independent Set Reduction
+//
+// ## Complement Graph Reduction (Karp 1972)
+// A set S is a clique in G iff S is an independent set in the complement
+// graph. The reduction builds the complement graph and preserves weights.
+//
+// ## This Example
+// - Instance: Path graph P4 with 4 vertices, edges {(0,1),(1,2),(2,3)}
+// - Complement has edges {(0,2),(0,3),(1,3)}
+// - Maximum clique = any edge = size 2
+// - Maximum independent set in complement = size 2
+//
+// ## Output
+// Exports `docs/paper/examples/maximumclique_to_maximumindependentset.json` and `maximumclique_to_maximumindependentset.result.json`.
+//
+// See docs/paper/reductions.typ for the full reduction specification.
+
+use problemreductions::export::*;
+use problemreductions::prelude::*;
+use problemreductions::topology::{Graph, SimpleGraph};
+
+pub fn run() {
+    // Path graph P4: 4 vertices, 3 edges
+    let clique = MaximumClique::new(
+        SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
+        vec![1i32; 4],
+    );
+
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&clique);
+    let is = reduction.target_problem();
+
+    println!("\n=== Problem Transformation ===");
+    println!(
+        "Source: MaximumClique with {} variables",
+        clique.num_variables()
+    );
+    println!(
+        "Target: MaximumIndependentSet with {} variables",
+        is.num_variables()
+    );
+    println!(
+        "Source edges: {}, Target (complement) edges: {}",
+        clique.graph().num_edges(),
+        is.graph().num_edges()
+    );
+
+    let solver = BruteForce::new();
+    let is_solutions = solver.find_all_best(is);
+    println!("\n=== Solution ===");
+    println!("Target solutions found: {}", is_solutions.len());
+
+    // Extract and verify solutions
+    let mut solutions = Vec::new();
+    for target_sol in &is_solutions {
+        let source_sol = reduction.extract_solution(target_sol);
+        let size = clique.evaluate(&source_sol);
+        assert!(size.is_valid());
+        solutions.push(SolutionPair {
+            source_config: source_sol.clone(),
+            target_config: target_sol.clone(),
+        });
+    }
+
+    let clique_solution = reduction.extract_solution(&is_solutions[0]);
+    println!("Source Clique solution: {:?}", clique_solution);
+
+    let size = clique.evaluate(&clique_solution);
+    println!("Solution size: {:?}", size);
+    assert!(size.is_valid());
+    println!("\nReduction verified successfully");
+
+    // Export JSON
+    let source_edges = clique.graph().edges();
+    let target_edges = is.graph().edges();
+    let source_variant = variant_to_map(MaximumClique::<SimpleGraph, i32>::variant());
+    let target_variant = variant_to_map(MaximumIndependentSet::<SimpleGraph, i32>::variant());
+    let overhead = lookup_overhead(
+        "MaximumClique",
+        &source_variant,
+        "MaximumIndependentSet",
+        &target_variant,
+    )
+    .expect("MaximumClique -> MaximumIndependentSet overhead not found");
+
+    let data = ReductionData {
+        source: ProblemSide {
+            problem: MaximumClique::<SimpleGraph, i32>::NAME.to_string(),
+            variant: source_variant,
+            instance: serde_json::json!({
+                "num_vertices": clique.graph().num_vertices(),
+                "num_edges": clique.graph().num_edges(),
+                "edges": source_edges,
+            }),
+        },
+        target: ProblemSide {
+            problem: MaximumIndependentSet::<SimpleGraph, i32>::NAME.to_string(),
+            variant: target_variant,
+            instance: serde_json::json!({
+                "num_vertices": is.graph().num_vertices(),
+                "num_edges": is.graph().num_edges(),
+                "edges": target_edges,
+            }),
+        },
+        overhead: overhead_to_json(&overhead),
+    };
+
+    let results = ResultData { solutions };
+    let name = "maximumclique_to_maximumindependentset";
+    write_example(name, &data, &results);
+}
+
+fn main() {
+    run()
+}

src/rules/maximumclique_maximumindependentset.rs

@@ -0,0 +1,71 @@
+//! Reduction from MaximumClique to MaximumIndependentSet via complement graph.
+//!
+//! A clique in G corresponds to an independent set in the complement graph.
+//! This is one of Karp's classical reductions (1972).
+
+use crate::models::graph::{MaximumClique, MaximumIndependentSet};
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::topology::{Graph, SimpleGraph};
+use crate::types::WeightElement;
+
+/// Result of reducing MaximumClique to MaximumIndependentSet.
+#[derive(Debug, Clone)]
+pub struct ReductionCliqueToIS<W> {
+    target: MaximumIndependentSet<SimpleGraph, W>,
+}
+
+impl<W> ReductionResult for ReductionCliqueToIS<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    type Source = MaximumClique<SimpleGraph, W>;
+    type Target = MaximumIndependentSet<SimpleGraph, W>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    /// Solution extraction: identity mapping.
+    /// A clique in G is an independent set in the complement, so the configuration is the same.
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        target_solution.to_vec()
+    }
+}
+
+/// Build the complement graph: edges between all non-adjacent vertex pairs.
+fn complement_edges(graph: &SimpleGraph) -> Vec<(usize, usize)> {
+    let n = graph.num_vertices();
+    let mut edges = Vec::new();
+    for u in 0..n {
+        for v in (u + 1)..n {
+            if !graph.has_edge(u, v) {
+                edges.push((u, v));
+            }
+        }
+    }
+    edges
+}
+
+#[reduction(
+    overhead = {
+        num_vertices = "num_vertices",
+        num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
+    }
+)]
+impl ReduceTo<MaximumIndependentSet<SimpleGraph, i32>> for MaximumClique<SimpleGraph, i32> {
+    type Result = ReductionCliqueToIS<i32>;
+
+    fn reduce_to(&self) -> Self::Result {
+        let comp_edges = complement_edges(self.graph());
+        let target = MaximumIndependentSet::new(
+            SimpleGraph::new(self.graph().num_vertices(), comp_edges),
+            self.weights().to_vec(),
+        );
+        ReductionCliqueToIS { target }
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/maximumclique_maximumindependentset.rs"]
+mod tests;

src/rules/mod.rs

@@ -14,6 +14,7 @@ mod kcoloring_casts;
 mod ksatisfiability_casts;
 mod ksatisfiability_qubo;
 mod ksatisfiability_subsetsum;
+mod maximumclique_maximumindependentset;
 mod maximumindependentset_casts;
 mod maximumindependentset_gridgraph;
 mod maximumindependentset_maximumclique;

src/unit_tests/rules/maximumclique_maximumindependentset.rs

@@ -0,0 +1,114 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::topology::Graph;
+use crate::traits::Problem;
+use crate::types::SolutionSize;
+use std::collections::HashSet;
+
+#[test]
+fn test_maximumclique_to_maximumindependentset_closed_loop() {
+    // Path graph P4: vertices {0,1,2,3}, edges {(0,1),(1,2),(2,3)}
+    // Maximum clique is any edge, size 2.
+    // Complement has edges {(0,2),(0,3),(1,3)}, MIS of size 2.
+    let source = MaximumClique::new(
+        SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
+        vec![1i32; 4],
+    );
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    // Verify complement graph structure
+    assert_eq!(target.graph().num_vertices(), 4);
+    assert_eq!(target.graph().num_edges(), 3); // 4*3/2 - 3 = 3
+
+    let solver = BruteForce::new();
+
+    // Solve target (MIS on complement graph)
+    let target_solutions = solver.find_all_best(target);
+    assert!(!target_solutions.is_empty());
+
+    // Solve source directly
+    let source_solutions: HashSet<Vec<usize>> = solver.find_all_best(&source).into_iter().collect();
+    assert!(!source_solutions.is_empty());
+
+    // Extract solutions and verify they are optimal for source
+    for target_sol in &target_solutions {
+        let source_sol = reduction.extract_solution(target_sol);
+        assert!(source_solutions.contains(&source_sol));
+    }
+}
+
+#[test]
+fn test_maximumclique_to_maximumindependentset_triangle() {
+    // Complete graph K3: all 3 edges present
+    // Complement is empty graph (no edges)
+    // MIS on empty graph = all vertices
+    let source = MaximumClique::new(
+        SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]),
+        vec![1i32; 3],
+    );
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    // Complement of K3 has no edges
+    assert_eq!(target.graph().num_edges(), 0);
+
+    let solver = BruteForce::new();
+    let target_solutions = solver.find_all_best(target);
+
+    // MIS on empty graph is all vertices selected
+    assert!(target_solutions
+        .iter()
+        .any(|s| s.iter().sum::<usize>() == 3));
+
+    // Extract solution: should be the full clique {0,1,2}
+    let source_sol = reduction.extract_solution(&target_solutions[0]);
+    assert!(matches!(
+        source.evaluate(&source_sol),
+        SolutionSize::Valid(3)
+    ));
+}
+
+#[test]
+fn test_maximumclique_to_maximumindependentset_weights_preserved() {
+    let source = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 20, 30]);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    assert_eq!(target.weights().to_vec(), vec![10, 20, 30]);
+}
+
+#[test]
+fn test_maximumclique_to_maximumindependentset_empty_graph() {
+    // Empty graph (no edges): complement is complete graph
+    // Max clique in empty graph = any single vertex
+    let source = MaximumClique::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    // Complement of empty graph is K3
+    assert_eq!(target.graph().num_edges(), 3);
+
+    let solver = BruteForce::new();
+    let target_solutions = solver.find_all_best(target);
+
+    // MIS on K3 is any single vertex
+    assert!(target_solutions
+        .iter()
+        .all(|s| s.iter().sum::<usize>() == 1));
+}
+
+#[test]
+fn test_maximumclique_to_maximumindependentset_overhead() {
+    // Verify overhead formula: complement edges = n*(n-1)/2 - m
+    let source = MaximumClique::new(
+        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
+        vec![1i32; 5],
+    );
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    assert_eq!(target.graph().num_vertices(), 5);
+    // 5*4/2 - 4 = 6
+    assert_eq!(target.graph().num_edges(), 6);
+}

tests/suites/examples.rs

@@ -25,6 +25,7 @@ example_test!(reduction_ksatisfiability_to_subsetsum);
 example_test!(reduction_ksatisfiability_to_satisfiability);
 example_test!(reduction_maxcut_to_spinglass);
 example_test!(reduction_maximumclique_to_ilp);
+example_test!(reduction_maximumclique_to_maximumindependentset);
 example_test!(reduction_maximumindependentset_to_ilp);
 example_test!(reduction_maximumindependentset_to_maximumclique);
 example_test!(reduction_maximumindependentset_to_maximumsetpacking);
@@ -99,6 +100,10 @@ example_fn!(
 );
 example_fn!(test_maxcut_to_spinglass, reduction_maxcut_to_spinglass);
 example_fn!(test_maximumclique_to_ilp, reduction_maximumclique_to_ilp);
+example_fn!(
+    test_maximumclique_to_maximumindependentset,
+    reduction_maximumclique_to_maximumindependentset
+);
 example_fn!(
     test_maximumindependentset_to_ilp,
     reduction_maximumindependentset_to_ilp