Tighten direct QUBO bounds and replace costly encodings

Author: isPANN

docs/paper/reductions.typ

@@ -32,7 +32,7 @@ impl ReductionResult for ReductionCyclicOrderingToQUBO {
 }
 #[crate::aggregate_reduction(identity)]
 impl crate::rules::AggregateReductionResult for ReductionCyclicOrderingToQUBO {}
-#[crate::reduction(transform = { exact { num_vars = "num_elements * (num_elements - 1) / 2" }, upper_bound { num_quadratic_terms = "(num_elements * (num_elements - 1) / 2)^2" } })]
+#[crate::reduction(transform = { exact { num_vars = "num_elements * (num_elements - 1) / 2" }, upper_bound { num_quadratic_terms = "num_elements * (num_elements - 1) * (num_elements - 2) / 2" } })]
 impl ReduceTo<Decision<QUBO<i64>>> for CyclicOrdering {
     type Result = ReductionCyclicOrderingToQUBO;
     fn reduce_to(&self) -> Result<Self::Result, ReductionError> {

src/rules/cyclicordering_qubo.rs

@@ -349,7 +349,6 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(minimumtardinesssequencingweighted_qubo::canonical_rule_example_specs());
     specs.extend(sequencingwithreleasetimesanddeadlines_qubo::canonical_rule_example_specs());
     specs.extend(dynamicstorageallocation_qubo::canonical_rule_example_specs());
-    specs.extend(shortestcommonsupersequence_qubo::canonical_rule_example_specs());
     specs.extend(minimumtardinesssequencing_qubo::canonical_rule_example_specs());
     specs.extend(quadraticassignment_qubo::canonical_rule_example_specs());
     specs.extend(sumofsquarespartition_qubo::canonical_rule_example_specs());
@@ -753,5 +752,4 @@ pub(crate) mod staffscheduling_qubo;
 pub(crate) mod dynamicstorageallocation_qubo;
 pub(crate) mod minimumtardinesssequencingweighted_qubo;
 pub(crate) mod sequencingwithreleasetimesanddeadlines_qubo;
-pub(crate) mod shortestcommonsupersequence_qubo;
 mod start_time_qubo;

src/rules/mod.rs

@@ -1,7 +1,7 @@
-//! Direct quadratic encoding of OptimalLinearArrangement<SimpleGraph>.
+//! Tournament comparisons encode the vertices between each edge's endpoints.
 use crate::models::algebraic::QUBO;
 use crate::models::graph::OptimalLinearArrangement;
-use crate::rules::qubo_helpers::{decode_rows, ObjectiveEncoding, QuboBuilder};
+use crate::rules::qubo_helpers::{pair_index, tournament_ranks, ObjectiveEncoding, QuboBuilder};
 use crate::rules::{ExtractionResult, ReduceTo, ReductionError, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 use crate::types::Min;
@@ -20,10 +20,7 @@ impl ReductionResult for ReductionOptimalLinearArrangementToQUBO {
     }
     fn extract_solution(&self, bits: &Vec<bool>) -> ExtractionResult<Vec<usize>> {
         self.encoding.validate(bits)?;
-        decode_rows(
-            bits,
-            std::iter::repeat_n(self.num_vertices, self.num_vertices),
-        )
+        tournament_ranks(self.num_vertices, bits)
     }
 }
 
@@ -40,26 +37,45 @@ impl crate::rules::AggregateReductionResult for ReductionOptimalLinearArrangemen
 }
 
 #[crate::reduction(transform = {
-    exact { num_vars = "num_vertices^2" },
-    upper_bound { num_quadratic_terms = "num_vertices^2 * (num_vertices^2 - 1) / 2" },
+    exact { num_vars = "num_vertices * (num_vertices - 1) / 2" },
+    upper_bound { num_quadratic_terms = "num_vertices * (num_vertices - 1) * (num_vertices - 2) / 2" },
 })]
 impl ReduceTo<QUBO<i64>> for OptimalLinearArrangement<SimpleGraph> {
     type Result = ReductionOptimalLinearArrangementToQUBO;
     fn reduce_to(&self) -> Result<Self::Result, ReductionError> {
         type Builder = QuboBuilder<OptimalLinearArrangement<SimpleGraph>, QUBO<i64>>;
         let n = self.num_vertices();
-        let mut q = Builder::new(Builder::dimension(n, n)?);
+        let mut q = Builder::new(Builder::dimension(n, n.saturating_sub(1))? / 2);
+        let edges =
+            <Self as ReduceTo<QUBO<i64>>>::exact_i64(self.num_edges(), "counting graph edges")?;
+        let span = <Self as ReduceTo<QUBO<i64>>>::exact_i64(
+            n.saturating_sub(1),
+            "bounding rank distance",
+        )?;
+        let high = edges.checked_mul(span).ok_or_else(Builder::overflow)?;
+        let penalty = high.checked_add(1).ok_or_else(Builder::overflow)?;
+        q.add_constant(i128::from(edges))?;
         for (u, v) in self.graph().edges() {
-            for p in 0..n {
-                for s in 0..n {
-                    q.add(u * n + p, v * n + s, p.abs_diff(s) as i128)?;
+            for w in 0..n {
+                if w == u || w == v {
+                    continue;
                 }
+                let a = pair_index(n, u.min(w), u.max(w));
+                let b = pair_index(n, v.min(w), v.max(w));
+                let ca = i128::from(u > w);
+                let cb = i128::from(v > w);
+                let sa = 1 - 2 * ca;
+                let sb = 1 - 2 * cb;
+                // XOR of the two comparisons identifies a vertex strictly between u and v.
+                q.add_constant(ca + cb - 2 * ca * cb)?;
+                q.add(a, a, sa * (1 - 2 * cb))?;
+                q.add(b, b, sb * (1 - 2 * ca))?;
+                q.add(a, b, -2 * sa * sb)?;
             }
         }
-        let (penalty, low, high) = q.penalty()?;
-        q.assignment(n, n, true, penalty)?;
+        q.tournament(n, &[], penalty)?;
         Ok(ReductionOptimalLinearArrangementToQUBO {
-            encoding: q.optimization(low, high)?,
+            encoding: q.optimization(0, high)?,
             num_vertices: n,
         })
     }
@@ -74,9 +90,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 OptimalLinearArrangement::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)])),
                 crate::export::SolutionPair {
                     source_config: serde_json::json!([0, 1, 2]),
-                    target_config: serde_json::json!([
-                        true, false, false, false, true, false, false, false, true
-                    ]),
+                    target_config: serde_json::json!([true, true, true]),
                 },
             )
         },

src/rules/optimallineararrangement_qubo.rs

@@ -54,7 +54,7 @@ impl crate::rules::AggregateReductionResult for ReductionShortestCommonSuperstri
         self.encoding.value(value)
     }
 }
-#[crate::reduction(transform = upper_bound { num_vars = "num_strings^2", num_quadratic_terms = "num_strings^4" })]
+#[crate::reduction(transform = upper_bound { num_vars = "num_strings^2", num_quadratic_terms = "num_strings * (num_strings - 1) * (2 * num_strings - 1)" })]
 impl ReduceTo<QUBO<i64>> for ShortestCommonSuperstring {
     type Result = ReductionShortestCommonSuperstringToQUBO;
     fn reduce_to(&self) -> Result<Self::Result, ReductionError> {

src/rules/shortestcommonsupersequence_qubo.rs

@@ -38,7 +38,7 @@ impl crate::rules::AggregateReductionResult for ReductionStackerCraneToQUBO {
         self.encoding.value(value)
     }
 }
-#[crate::reduction(transform = { exact { num_vars = "num_arcs^2" }, upper_bound { num_quadratic_terms = "num_arcs^4" } })]
+#[crate::reduction(transform = { exact { num_vars = "num_arcs^2" }, upper_bound { num_quadratic_terms = "2 * num_arcs^2 * (num_arcs - 1)" } })]
 impl ReduceTo<QUBO<i64>> for StackerCrane {
     type Result = ReductionStackerCraneToQUBO;
     fn reduce_to(&self) -> Result<Self::Result, ReductionError> {

src/rules/shortestcommonsuperstring_qubo.rs

@@ -49,7 +49,7 @@ impl crate::rules::AggregateReductionResult for ReductionStaffSchedulingToQUBO {
 
 #[crate::reduction(transform = upper_bound {
     num_vars = "63 * (num_schedules + num_periods + 1)",
-    num_quadratic_terms = "(63 * (num_schedules + num_periods + 1))^2",
+    num_quadratic_terms = "63 * (num_schedules + 1) * (63 * (num_schedules + 1) - 1) / 2 + num_periods * (3969 * num_schedules + 1953)",
 })]
 impl ReduceTo<Decision<QUBO<i64>>> for StaffScheduling {
     type Result = ReductionStaffSchedulingToQUBO;