update

Author: GiggleLiu

src/rules/maximumindependentset_gridgraph.rs

@@ -55,51 +55,6 @@ impl ReduceTo<MaximumIndependentSet<KingsSubgraph, One>>
     }
 }
 
-/// Result of reducing MIS<SimpleGraph, One> to MIS<KingsSubgraph, i32>.
-#[derive(Debug, Clone)]
-pub struct ReductionISSimpleOneToGridWeighted {
-    target: MaximumIndependentSet<KingsSubgraph, i32>,
-    mapping_result: ksg::MappingResult<ksg::KsgTapeEntry>,
-}
-
-impl ReductionResult for ReductionISSimpleOneToGridWeighted {
-    type Source = MaximumIndependentSet<SimpleGraph, One>;
-    type Target = MaximumIndependentSet<KingsSubgraph, i32>;
-
-    fn target_problem(&self) -> &Self::Target {
-        &self.target
-    }
-
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.mapping_result.map_config_back(target_solution)
-    }
-}
-
-#[reduction(
-    overhead = {
-        num_vertices = "num_vertices * num_vertices",
-        num_edges = "num_vertices * num_vertices",
-    }
-)]
-impl ReduceTo<MaximumIndependentSet<KingsSubgraph, i32>>
-    for MaximumIndependentSet<SimpleGraph, One>
-{
-    type Result = ReductionISSimpleOneToGridWeighted;
-
-    fn reduce_to(&self) -> Self::Result {
-        let n = self.graph().num_vertices();
-        let edges = self.graph().edges();
-        let result = ksg::map_unweighted(n, &edges);
-        let weights = result.node_weights.clone();
-        let grid = result.to_kings_subgraph();
-        let target = MaximumIndependentSet::new(grid, weights);
-        ReductionISSimpleOneToGridWeighted {
-            target,
-            mapping_result: result,
-        }
-    }
-}
-
 #[cfg(test)]
 #[path = "../unit_tests/rules/maximumindependentset_gridgraph.rs"]
 mod tests;

src/unit_tests/rules/analysis.rs

@@ -254,11 +254,6 @@ fn test_find_dominated_rules_returns_known_set() {
         ("Factoring", "ILP {variable: \"i32\"}"),
         // K3-SAT → QUBO via SAT → CircuitSAT → SpinGlass chain
         ("KSatisfiability {k: \"K3\"}", "QUBO {weight: \"f64\"}"),
-        // Variant cast composed: SimpleGraph/One → KingsSubgraph/One → KingsSubgraph/i32
-        (
-            "MaximumIndependentSet {graph: \"SimpleGraph\", weight: \"One\"}",
-            "MaximumIndependentSet {graph: \"KingsSubgraph\", weight: \"i32\"}",
-        ),
         // MaxMatching → MaxSetPacking → ILP is better than direct MaxMatching → ILP
         (
             "MaximumMatching {graph: \"SimpleGraph\", weight: \"i32\"}",

src/unit_tests/rules/maximumindependentset_gridgraph.rs

@@ -52,24 +52,3 @@ fn test_mis_simple_one_to_kings_one_closed_loop() {
     let size: usize = original_solution.iter().sum();
     assert_eq!(size, 3, "Max IS in path of 5 should be 3");
 }
-
-#[test]
-fn test_mis_simple_one_to_kings_weighted_closed_loop() {
-    // Path graph: 0-1-2-3-4 (MIS = 3: select vertices 0, 2, 4)
-    let problem = MaximumIndependentSet::new(
-        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![One; 5],
-    );
-    let result = ReduceTo::<MaximumIndependentSet<KingsSubgraph, i32>>::reduce_to(&problem);
-    let target = result.target_problem();
-    assert!(target.graph().num_vertices() > 5);
-
-    let solver = BruteForce::new();
-    let grid_solutions = solver.find_all_best(target);
-    assert!(!grid_solutions.is_empty());
-
-    let original_solution = result.extract_solution(&grid_solutions[0]);
-    assert_eq!(original_solution.len(), 5);
-    let size: usize = original_solution.iter().sum();
-    assert_eq!(size, 3, "Max IS in path of 5 should be 3");
-}