Fix #73: Refactor graph problem constructors to take graph as input (#74)

* Add plan for #73: Refactor graph problem constructors

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

* save issue templates

* refactor: replace MaximumIndependentSet SimpleGraph-only constructors with generic new(graph, weights)

Remove the `impl<W> MaximumIndependentSet<SimpleGraph, W>` block containing
`new(num_vertices, edges)` and `with_weights(num_vertices, edges, weights)`.
Rename `from_graph` to `new` in the generic impl block, making all graph
types use the same `MaximumIndependentSet::new(graph, weights)` constructor.

Update all call sites across rules, unit tests, integration tests, examples,
benchmarks, and doc comments to use the new pattern:
- `MaximumIndependentSet::<SimpleGraph, i32>::new(n, edges)` becomes
  `MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; n])`
- `MaximumIndependentSet::with_weights(n, edges, w)` becomes
  `MaximumIndependentSet::new(SimpleGraph::new(n, edges), w)`
- `MaximumIndependentSet::from_graph(g, w)` becomes
  `MaximumIndependentSet::new(g, w)`

Part of #73 (graph constructor refactoring).

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

* refactor: replace SimpleGraph-only constructors for MVC, MDS, MaxClique, MaximalIS

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

* refactor: replace KColoring SimpleGraph-only constructors, rename from_graph -> new

- Delete `impl<K: KValue> KColoring<K, SimpleGraph>` block with `new(num_vertices, edges)`
- Rename `from_graph(graph)` -> `new(graph)` in generic `impl<K: KValue, G: Graph>`
- Rename `from_graph_with_k(graph, k)` -> `with_k(graph, k)` in `impl<G: Graph> KColoring<KN, G>`
- Update all call sites: wrap edges in `SimpleGraph::new(n, edges)` and use `KColoring::<K3, _>::new(...)`
- Update doc example, rules, unit tests, integration tests, examples, and benchmarks

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

* refactor: replace SimpleGraph-only constructors for MaxCut, MaximumMatching, TravelingSalesman

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

* refactor: type-based is_weighted via WeightElement::IS_UNIT

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

* refactor: public helper functions take graph reference instead of raw vertices/edges

Update 8 public helper functions (is_independent_set, is_vertex_cover,
is_clique, is_maximal_independent_set, is_dominating_set, is_matching,
is_hamiltonian_cycle, is_valid_coloring) to accept `&G where G: Graph`
instead of `(num_vertices, edges)`. Size mismatches now panic via
assert_eq! instead of returning false.

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

* fix: address PR review comments, remove plan file

- TravelingSalesman: guard against wrong-length config in private helper
- is_dominating_set/is_maximal_independent_set: pre-build adjacency list
  to avoid per-vertex allocation in loop
- Remove plan file

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

---------

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

Author: GiggleLiu

.github/ISSUE_TEMPLATE/problem.md

@@ -7,6 +7,10 @@ assignees: ''
 
 ---
 
+## Motivation
+
+<!-- One sentence: why is this problem useful to include? E.g. "Widely used in network design and has known reductions to QUBO." -->
+
 ## Definition
 
 **Name:** <!-- e.g. MaximumIndependentSet. Use Maximum/Minimum prefix for optimization problems -->

.github/ISSUE_TEMPLATE/rule.md

@@ -9,6 +9,7 @@ assignees: ''
 
 **Source:** <!-- e.g. MaximumIndependentSet. Browse existing problems: https://codingthrust.github.io/problem-reductions/ -->
 **Target:** <!-- e.g. QUBO -->
+**Motivation:** <!-- One sentence: why is this reduction useful? E.g. "Enables solving MIS on quantum annealers via QUBO formulation." -->
 **Reference:** <!-- URL, paper, or textbook citation for this reduction -->
 
 ## Reduction Algorithm

benches/solver_benchmarks.rs

@@ -18,7 +18,7 @@ fn bench_independent_set(c: &mut Criterion) {
     for n in [4, 6, 8, 10].iter() {
         // Create a path graph with n vertices
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let problem = MaximumIndependentSet::<SimpleGraph, i32>::new(*n, edges);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(*n, edges), vec![1i32; *n]);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
@@ -35,7 +35,7 @@ fn bench_vertex_covering(c: &mut Criterion) {
 
     for n in [4, 6, 8, 10].iter() {
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let problem = MinimumVertexCover::<SimpleGraph, i32>::new(*n, edges);
+        let problem = MinimumVertexCover::new(SimpleGraph::new(*n, edges), vec![1i32; *n]);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
@@ -51,8 +51,9 @@ fn bench_max_cut(c: &mut Criterion) {
     let mut group = c.benchmark_group("MaxCut");
 
     for n in [4, 6, 8, 10].iter() {
-        let edges: Vec<(usize, usize, i32)> = (0..*n - 1).map(|i| (i, i + 1, 1)).collect();
-        let problem = MaxCut::new(*n, edges);
+        let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
+        let weights = vec![1i32; edges.len()];
+        let problem = MaxCut::new(SimpleGraph::new(*n, edges), weights);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
@@ -139,7 +140,7 @@ fn bench_coloring(c: &mut Criterion) {
 
     for n in [3, 4, 5, 6].iter() {
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let problem = KColoring::<K3, SimpleGraph>::new(*n, edges);
+        let problem = KColoring::<K3, _>::new(SimpleGraph::new(*n, edges));
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path_3colors", n), n, |b, _| {
@@ -155,8 +156,9 @@ fn bench_matching(c: &mut Criterion) {
     let mut group = c.benchmark_group("Matching");
 
     for n in [4, 6, 8, 10].iter() {
-        let edges: Vec<(usize, usize, i32)> = (0..*n - 1).map(|i| (i, i + 1, 1)).collect();
-        let problem = MaximumMatching::new(*n, edges);
+        let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
+        let weights = vec![1i32; edges.len()];
+        let problem = MaximumMatching::new(SimpleGraph::new(*n, edges), weights);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
@@ -196,7 +198,7 @@ fn bench_comparison(c: &mut Criterion) {
 
     // MaximumIndependentSet with 8 vertices
     let is_problem =
-        MaximumIndependentSet::<SimpleGraph, i32>::new(8, vec![(0, 1), (2, 3), (4, 5), (6, 7)]);
+        MaximumIndependentSet::new(SimpleGraph::new(8, vec![(0, 1), (2, 3), (4, 5), (6, 7)]), vec![1i32; 8]);
     group.bench_function("MaximumIndependentSet", |b| {
         b.iter(|| solver.find_best(black_box(&is_problem)))
     });
@@ -226,7 +228,7 @@ fn bench_comparison(c: &mut Criterion) {
     });
 
     // MaxCut with 8 vertices
-    let mc_problem = MaxCut::new(8, vec![(0, 1, 1), (2, 3, 1), (4, 5, 1), (6, 7, 1)]);
+    let mc_problem = MaxCut::new(SimpleGraph::new(8, vec![(0, 1), (2, 3), (4, 5), (6, 7)]), vec![1, 1, 1, 1]);
     group.bench_function("MaxCut", |b| {
         b.iter(|| solver.find_best(black_box(&mc_problem)))
     });

docs/src/getting-started.md

@@ -35,7 +35,7 @@ use problemreductions::prelude::*;
 use problemreductions::topology::SimpleGraph;
 
 // 1. Create: Independent Set on a path graph (4 vertices)
-let problem = MaximumIndependentSet::<SimpleGraph, i32>::new(4, vec![(0, 1), (1, 2), (2, 3)]);
+let problem = MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), vec![1i32; 4]);
 
 // 2. Reduce: Transform to Minimum Vertex Cover
 let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&problem);

examples/reduction_kcoloring_to_ilp.rs

@@ -24,7 +24,7 @@ use problemreductions::topology::{Graph, SimpleGraph};
 pub fn run() {
     // 1. Create KColoring instance: Petersen graph (10 vertices, 15 edges) with 3 colors, χ=3
     let (num_vertices, edges) = petersen();
-    let coloring = KColoring::<K3, SimpleGraph>::new(num_vertices, edges.clone());
+    let coloring = KColoring::<K3, _>::new(SimpleGraph::new(num_vertices, edges.clone()));
 
     // 2. Reduce to ILP
     let reduction = ReduceTo::<ILP>::reduce_to(&coloring);

examples/reduction_kcoloring_to_qubo.rs

@@ -38,7 +38,7 @@ pub fn run() {
 
     // House graph: 5 vertices, 6 edges (square base + triangle roof), χ=3
     let (num_vertices, edges) = house();
-    let kc = KColoring::<K3, SimpleGraph>::new(num_vertices, edges.clone());
+    let kc = KColoring::<K3, _>::new(SimpleGraph::new(num_vertices, edges.clone()));
 
     // Reduce to QUBO
     let reduction = ReduceTo::<QUBO>::reduce_to(&kc);

examples/reduction_maxcut_to_spinglass.rs

@@ -22,7 +22,7 @@ use problemreductions::topology::{Graph, SimpleGraph};
 
 pub fn run() {
     let (num_vertices, edges) = petersen();
-    let maxcut = MaxCut::<SimpleGraph, i32>::unweighted(num_vertices, edges.clone());
+    let maxcut = MaxCut::<_, i32>::unweighted(SimpleGraph::new(num_vertices, edges.clone()));
 
     let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&maxcut);
     let sg = reduction.target_problem();

examples/reduction_maximumclique_to_ilp.rs

@@ -22,7 +22,7 @@ use problemreductions::topology::{Graph, SimpleGraph};
 pub fn run() {
     // 1. Create MaximumClique instance: Octahedron (K_{2,2,2}), 6 vertices, 12 edges, clique number 3
     let (num_vertices, edges) = octahedral();
-    let clique = MaximumClique::<SimpleGraph, i32>::new(num_vertices, edges.clone());
+    let clique = MaximumClique::new(SimpleGraph::new(num_vertices, edges.clone()), vec![1i32; num_vertices]);
 
     // 2. Reduce to ILP
     let reduction = ReduceTo::<ILP>::reduce_to(&clique);

examples/reduction_maximumindependentset_to_ilp.rs

@@ -21,7 +21,7 @@ use problemreductions::topology::{Graph, SimpleGraph};
 pub fn run() {
     // 1. Create IS instance: Petersen graph
     let (num_vertices, edges) = petersen();
-    let is = MaximumIndependentSet::<SimpleGraph, i32>::new(num_vertices, edges.clone());
+    let is = MaximumIndependentSet::new(SimpleGraph::new(num_vertices, edges.clone()), vec![1i32; num_vertices]);
 
     // 2. Reduce to ILP
     let reduction = ReduceTo::<ILP>::reduce_to(&is);

examples/reduction_maximumindependentset_to_maximumsetpacking.rs

@@ -25,7 +25,7 @@ pub fn run() {
 
     // Petersen graph: 10 vertices, 15 edges, 3-regular
     let (num_vertices, edges) = petersen();
-    let source = MaximumIndependentSet::<SimpleGraph, i32>::new(num_vertices, edges.clone());
+    let source = MaximumIndependentSet::new(SimpleGraph::new(num_vertices, edges.clone()), vec![1i32; num_vertices]);
 
     println!("Source: MaximumIndependentSet on Petersen graph");
     println!("  Vertices: {}", num_vertices);