Drop dominated MaxClique cast; add <One> closed-loop tests

The `MaximumClique<SG,One> → MaximumClique<SG,i32>` direct cast is
dominated by the existing `MC<SG,One> → MIS<SG,One> → MIS<SG,i32>
→ MC<SG,i32>` path, which the redundancy-sanity test flags in
`rules::analysis::tests::test_find_dominated_rules_returns_known_set`.
Remove the cast entirely (and its now-empty `maximumclique_casts.rs`);
the cast-less `<One> → <i32>` path is still reachable via MIS, so
`pred path MaximumIndependentSet MaximumClique` stays on `One` without
the `i32` detour.

Also:
- add `<One>` closed-loop tests for both MC↔MIS reduction directions
  and a `MaximumClique<SG,One>` model-level evaluate/solve test,
- drop the redundant `Clone + Default` bounds on
  `reduce_clique_to_is`/`reduce_is_to_clique` (already implied by
  `WeightElement`),
- move the stray `use super::graph_helpers::complement_edges;` in
  `kcoloring_partitionintocliques.rs` up with the other imports.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: GiggleLiu

src/rules/kcoloring_partitionintocliques.rs

@@ -5,6 +5,7 @@
 
 use crate::models::graph::{KColoring, PartitionIntoCliques};
 use crate::reduction;
+use crate::rules::graph_helpers::complement_edges;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 use crate::variant::KN;
@@ -29,8 +30,6 @@ impl ReductionResult for ReductionKColoringToPartitionIntoCliques {
     }
 }
 
-use super::graph_helpers::complement_edges;
-
 #[reduction(
     overhead = {
         num_vertices = "num_vertices",

src/rules/maximumclique_casts.rs

@@ -33,7 +33,7 @@ where
     }
 }
 
-fn reduce_clique_to_is<W: WeightElement + Clone + Default>(
+fn reduce_clique_to_is<W: WeightElement>(
     src: &MaximumClique<SimpleGraph, W>,
 ) -> ReductionCliqueToIS<W> {
     let comp_edges = super::graph_helpers::complement_edges(src.graph());

src/rules/maximumclique_maximumindependentset.rs

@@ -33,7 +33,7 @@ where
     }
 }
 
-fn reduce_is_to_clique<W: WeightElement + Clone + Default>(
+fn reduce_is_to_clique<W: WeightElement>(
     src: &MaximumIndependentSet<SimpleGraph, W>,
 ) -> ReductionISToClique<W> {
     let comp_edges = super::graph_helpers::complement_edges(src.graph());

src/rules/maximumindependentset_maximumclique.rs

@@ -71,7 +71,6 @@ pub(crate) mod ksatisfiability_timetabledesign;
 pub(crate) mod longestcommonsubsequence_maximumindependentset;
 pub(crate) mod maxcut_minimumcutintoboundedsets;
 pub(crate) mod maximum2satisfiability_maxcut;
-mod maximumclique_casts;
 pub(crate) mod maximumclique_maximumindependentset;
 mod maximumindependentset_casts;
 mod maximumindependentset_gridgraph;

src/rules/mod.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
-use crate::types::Max;
+use crate::types::{Max, One};
 
 #[test]
 fn test_clique_creation() {
@@ -281,6 +281,29 @@ fn test_size_getters() {
     assert_eq!(problem.num_edges(), 2);
 }
 
+#[test]
+fn test_clique_one_weights_evaluate_and_solve() {
+    use crate::traits::Problem;
+
+    // Triangle with unit weights: max clique covers all 3 vertices.
+    let problem = MaximumClique::new(
+        SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
+        vec![One; 3],
+    );
+    assert!(!problem.is_weighted());
+    assert_eq!(problem.evaluate(&[1, 1, 1]), Max(Some(3)));
+    assert_eq!(problem.evaluate(&[1, 1, 0]), Max(Some(2)));
+    // Invalid clique on this graph? K3 is complete, so every subset is a clique.
+    // Re-verify invalidity on a path graph:
+    let path = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![One; 3]);
+    assert_eq!(path.evaluate(&[1, 0, 1]), Max(None));
+
+    let solver = BruteForce::new();
+    let solutions = solver.find_all_witnesses(&problem);
+    assert_eq!(solutions.len(), 1);
+    assert_eq!(solutions[0], vec![1, 1, 1]);
+}
+
 #[test]
 fn test_clique_paper_example() {
     use crate::traits::Problem;

src/unit_tests/models/graph/maximum_clique.rs

@@ -3,6 +3,7 @@ use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization
 use crate::solvers::BruteForce;
 use crate::topology::Graph;
 use crate::traits::Problem;
+use crate::types::One;
 
 #[test]
 fn test_maximumclique_to_maximumindependentset_closed_loop() {
@@ -84,6 +85,27 @@ fn test_maximumclique_to_maximumindependentset_empty_graph() {
         .all(|s| s.iter().sum::<usize>() == 1));
 }
 
+#[test]
+fn test_maximumclique_to_maximumindependentset_one_weights_closed_loop() {
+    // Same P4 as the i32 closed-loop test, but with unit weights so the
+    // reduction stays on the <SimpleGraph, One> endpoint (no i32 detour).
+    let source = MaximumClique::new(
+        SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
+        vec![One; 4],
+    );
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    assert_eq!(target.graph().num_vertices(), 4);
+    assert_eq!(target.graph().num_edges(), 3);
+
+    assert_optimization_round_trip_from_optimization_target(
+        &source,
+        &reduction,
+        "MaximumClique<One>->MaximumIndependentSet<One> closed loop",
+    );
+}
+
 #[test]
 fn test_maximumclique_to_maximumindependentset_overhead() {
     // Verify overhead formula: complement edges = n*(n-1)/2 - m

src/unit_tests/rules/maximumclique_maximumindependentset.rs

@@ -2,6 +2,7 @@ use super::*;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
+use crate::types::One;
 
 #[test]
 fn test_maximumindependentset_to_maximumclique_closed_loop() {
@@ -66,6 +67,26 @@ fn test_maximumindependentset_to_maximumclique_empty_graph() {
     assert!(best_target.iter().all(|s| s.iter().sum::<usize>() == 4));
 }
 
+#[test]
+fn test_maximumindependentset_to_maximumclique_one_weights_closed_loop() {
+    // Unit-weight closed loop: <SimpleGraph, One> endpoint stays on One all the way.
+    let source = MaximumIndependentSet::new(
+        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
+        vec![One; 5],
+    );
+    let reduction = ReduceTo::<MaximumClique<SimpleGraph, One>>::reduce_to(&source);
+    let target = reduction.target_problem();
+
+    assert_eq!(target.num_vertices(), 5);
+    assert_eq!(target.num_edges(), 6);
+
+    assert_optimization_round_trip_from_optimization_target(
+        &source,
+        &reduction,
+        "MaximumIndependentSet<One>->MaximumClique<One> closed loop",
+    );
+}
+
 #[test]
 fn test_maximumindependentset_to_maximumclique_complete_graph() {
     // Complete graph K4 - complement is empty graph