feat: add 10 reduction rules (#770) (#972)

* feat: add 10 reduction rules from #770

Add 10 new reduction rules connecting existing problem models:

Tier 1a (simple):
- Partition → BinPacking (#396): capacity=S/2, identity extraction
- ExactCoverBy3Sets → MaximumSetPacking (#823): identity transformation
- NAESatisfiability → MaxCut (#821): literal-pair edges + variable edges

ThreePartition scheduling (5 rules):
- ThreePartition → ResourceConstrainedScheduling (#477): 3 processors, resource=size
- ThreePartition → SequencingWithReleaseTimesAndDeadlines (#469): filler-task slots
- ThreePartition → SequencingToMinimizeWeightedTardiness (#473): filler-task slots
- ThreePartition → FlowShopScheduling (#482): 3-machine separators
- ThreePartition → JobShopScheduling (#485): 2-processor separators

ILP/graph:
- ILP/i32 → ILP/bool (#769): FBBT + truncated binary encoding
- MaxCut → MinimumCutIntoBoundedSets (#849): complement graph bisection

Also adds num_literal_pairs() getter to NAESatisfiability model and
updates dominated-rules allow-list and path parity tests.

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

* fix: register 9 missing rules in mod.rs and address review findings

- Register all 9 unregistered rule modules in rules/mod.rs (were dead code)
- Wire 9 canonical rule example specs in canonical_rule_example_specs()
- Add ExactCoverBy3Sets -> ILP to dominated-rules allow-list
- Rename misleading test_..._infeasible to test_..._two_triples
- Fix unused variable warning in JobShopScheduling example builder

Test count: 4258 -> 4312 (54 previously-dead tests now compiled and passing)

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

* fix: use MinimizeStepsThenOverhead in MaxCut->QUBO parity test

The new reduction rules (especially MaxCut -> MinCutBounded) created
an alternative 3-step path to QUBO via complete graph construction,
producing O(n^4) QUBO variables. MinimizeSteps tied at 3 steps and
the tie-breaker selected this expensive path. Using
MinimizeStepsThenOverhead with actual problem size (Petersen: 10v, 15e)
ensures the compact SpinGlass path is chosen.

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

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: zazabap

src/models/formula/nae_satisfiability.rs

@@ -69,6 +69,16 @@ impl NAESatisfiability {
         self.clauses.iter().map(|c| c.len()).sum()
     }
 
+    /// Get the total number of literal pairs across all clauses.
+    ///
+    /// For each clause with k literals, this contributes C(k,2) = k*(k-1)/2 pairs.
+    pub fn num_literal_pairs(&self) -> usize {
+        self.clauses
+            .iter()
+            .map(|c| c.len() * (c.len() - 1) / 2)
+            .sum()
+    }
+
     /// Get the clauses.
     pub fn clauses(&self) -> &[CNFClause] {
         &self.clauses

src/rules/exactcoverby3sets_maximumsetpacking.rs

@@ -0,0 +1,82 @@
+//! Reduction from ExactCoverBy3Sets to MaximumSetPacking.
+//!
+//! Given an X3C instance with universe X (|X| = 3q) and collection C of
+//! 3-element subsets, construct a MaximumSetPacking<One> instance where each
+//! triple becomes a variable-length set with unit weight. An exact cover
+//! of q disjoint triples corresponds to a maximum packing of value q.
+
+use crate::models::set::{ExactCoverBy3Sets, MaximumSetPacking};
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::types::One;
+
+/// Result of reducing ExactCoverBy3Sets to MaximumSetPacking<One>.
+#[derive(Debug, Clone)]
+pub struct ReductionXC3SToMaximumSetPacking {
+    target: MaximumSetPacking<One>,
+}
+
+impl ReductionResult for ReductionXC3SToMaximumSetPacking {
+    type Source = ExactCoverBy3Sets;
+    type Target = MaximumSetPacking<One>;
+
+    fn target_problem(&self) -> &MaximumSetPacking<One> {
+        &self.target
+    }
+
+    /// Extract X3C solution from MaximumSetPacking solution.
+    ///
+    /// The configuration is identity (same binary selection vector).
+    /// A packing of q disjoint 3-sets over a 3q-element universe is necessarily
+    /// an exact cover, so no additional checking is needed.
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        target_solution.to_vec()
+    }
+}
+
+#[reduction(overhead = {
+    num_sets = "num_subsets",
+})]
+impl ReduceTo<MaximumSetPacking<One>> for ExactCoverBy3Sets {
+    type Result = ReductionXC3SToMaximumSetPacking;
+
+    fn reduce_to(&self) -> Self::Result {
+        let sets: Vec<Vec<usize>> = self
+            .subsets()
+            .iter()
+            .map(|triple| triple.to_vec())
+            .collect();
+
+        ReductionXC3SToMaximumSetPacking {
+            target: MaximumSetPacking::<One>::new(sets),
+        }
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    use crate::export::SolutionPair;
+
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "exactcoverby3sets_to_maximumsetpacking",
+        build: || {
+            // Universe {0,1,2,3,4,5}, subsets [{0,1,2}, {0,1,3}, {3,4,5}, {2,4,5}, {1,3,5}]
+            // Exact cover: S0={0,1,2} + S2={3,4,5}
+            let source = ExactCoverBy3Sets::new(
+                6,
+                vec![[0, 1, 2], [0, 1, 3], [3, 4, 5], [2, 4, 5], [1, 3, 5]],
+            );
+            crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<One>>(
+                source,
+                SolutionPair {
+                    source_config: vec![1, 0, 1, 0, 0],
+                    target_config: vec![1, 0, 1, 0, 0],
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/exactcoverby3sets_maximumsetpacking.rs"]
+mod tests;