Fix complexity inconsistencies, enforce overhead, add missing variants

docs/paper/reductions.typ

@@ -335,7 +335,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 #problem-def("MaximumIndependentSet")[
   Given $G = (V, E)$ with vertex weights $w: V -> RR$, find $S subset.eq V$ maximizing $sum_(v in S) w(v)$ such that no two vertices in $S$ are adjacent: $forall u, v in S: (u, v) in.not E$.
 ][
-One of Karp's 21 NP-complete problems @karp1972, MIS appears in wireless network scheduling, register allocation, and coding theory @shannon1956. Solvable in polynomial time on bipartite graphs (König's theorem), interval graphs, chordal graphs, and cographs. The best known algorithm runs in $O^*(1.1996^n)$ time via measure-and-conquer branching @xiao2017.
+One of Karp's 21 NP-complete problems @karp1972, MIS appears in wireless network scheduling, register allocation, and coding theory @shannon1956. Solvable in polynomial time on bipartite graphs (König's theorem), interval graphs, chordal graphs, and cographs. The best known algorithm runs in $O^*(1.1996^n)$ time via measure-and-conquer branching @xiao2017. On geometric graphs (King's subgraph, triangular subgraph, unit disk graphs), MIS admits subexponential $O^*(c^sqrt(n))$ algorithms for some constant $c$, via geometric separation @alber2004.
 
 *Example.* Consider the Petersen graph $G$ with $n = 10$ vertices, $|E| = 15$ edges, and unit weights $w(v) = 1$ for all $v in V$. The graph is 3-regular (every vertex has degree 3). A maximum independent set is $S = {v_1, v_3, v_5, v_9}$ with $w(S) = sum_(v in S) w(v) = 4 = alpha(G)$. No two vertices in $S$ share an edge, and no vertex can be added without violating independence.
 

docs/paper/references.bib

@@ -355,3 +355,14 @@ @article{shannon1956
   doi     = {10.1109/TIT.1956.1056798}
 }
 
+@article{alber2004,
+  author  = {Jochen Alber and Ji\v{r}\'{\i} Fiala},
+  title   = {Geometric separation and exact solutions for the parameterized independent set problem on disk graphs},
+  journal = {Journal of Algorithms},
+  volume  = {52},
+  number  = {2},
+  pages   = {134--151},
+  year    = {2004},
+  doi     = {10.1016/j.jalgor.2003.10.001}
+}
+

problemreductions-macros/src/lib.rs

@@ -253,7 +253,12 @@ fn generate_reduction_entry(
     let overhead = match &attrs.overhead {
         Some(OverheadSpec::Legacy(tokens)) => tokens.clone(),
         Some(OverheadSpec::Parsed(fields)) => generate_parsed_overhead(fields)?,
-        None => quote! { crate::rules::registry::ReductionOverhead::default() },
+        None => {
+            return Err(syn::Error::new(
+                proc_macro2::Span::call_site(),
+                "#[reduction] requires overhead = { ... }. Specify overhead expressions for all target problem size fields.",
+            ));
+        }
     };
 
     // Generate the combined output

src/models/graph/max_cut.rs

@@ -215,7 +215,7 @@ where
 }
 
 crate::declare_variants! {
-    MaxCut<SimpleGraph, i32> => "2^num_vertices",
+    MaxCut<SimpleGraph, i32> => "2^(omega * num_vertices / 3)",
 }
 
 #[cfg(test)]

src/models/graph/maximal_is.rs

@@ -216,7 +216,7 @@ pub(crate) fn is_maximal_independent_set<G: Graph>(graph: &G, selected: &[bool])
 }
 
 crate::declare_variants! {
-    MaximalIS<SimpleGraph, i32> => "2^num_vertices",
+    MaximalIS<SimpleGraph, i32> => "3^(num_vertices / 3)",
 }
 
 #[cfg(test)]

src/models/graph/maximum_clique.rs

@@ -171,7 +171,7 @@ fn is_clique_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
 }
 
 crate::declare_variants! {
-    MaximumClique<SimpleGraph, i32> => "2^num_vertices",
+    MaximumClique<SimpleGraph, i32> => "1.1996^num_vertices",
 }
 
 /// Check if a set of vertices forms a clique.

src/models/graph/maximum_independent_set.rs

@@ -160,13 +160,13 @@ fn is_independent_set_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
 }
 
 crate::declare_variants! {
-    MaximumIndependentSet<SimpleGraph, i32>        => "2^num_vertices",
-    MaximumIndependentSet<SimpleGraph, One>         => "2^num_vertices",
-    MaximumIndependentSet<KingsSubgraph, i32>      => "2^num_vertices",
-    MaximumIndependentSet<KingsSubgraph, One>       => "2^num_vertices",
-    MaximumIndependentSet<TriangularSubgraph, i32> => "2^num_vertices",
-    MaximumIndependentSet<UnitDiskGraph, i32>      => "2^num_vertices",
-    MaximumIndependentSet<UnitDiskGraph, One>       => "2^num_vertices",
+    MaximumIndependentSet<SimpleGraph, i32>        => "1.1996^num_vertices",
+    MaximumIndependentSet<SimpleGraph, One>         => "1.1996^num_vertices",
+    MaximumIndependentSet<KingsSubgraph, i32>      => "2^sqrt(num_vertices)",
+    MaximumIndependentSet<KingsSubgraph, One>       => "2^sqrt(num_vertices)",
+    MaximumIndependentSet<TriangularSubgraph, i32> => "2^sqrt(num_vertices)",
+    MaximumIndependentSet<UnitDiskGraph, i32>      => "2^sqrt(num_vertices)",
+    MaximumIndependentSet<UnitDiskGraph, One>       => "2^sqrt(num_vertices)",
 }
 
 /// Check if a set of vertices forms an independent set.

src/models/graph/minimum_dominating_set.rs

@@ -170,7 +170,7 @@ where
 }
 
 crate::declare_variants! {
-    MinimumDominatingSet<SimpleGraph, i32> => "2^num_vertices",
+    MinimumDominatingSet<SimpleGraph, i32> => "1.4969^num_vertices",
 }
 
 /// Check if a set of vertices is a dominating set.

src/models/graph/minimum_vertex_cover.rs

@@ -157,7 +157,7 @@ fn is_vertex_cover_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
 }
 
 crate::declare_variants! {
-    MinimumVertexCover<SimpleGraph, i32> => "2^num_vertices",
+    MinimumVertexCover<SimpleGraph, i32> => "1.1996^num_vertices",
 }
 
 /// Check if a set of vertices forms a vertex cover.

src/models/graph/traveling_salesman.rs

@@ -253,7 +253,7 @@ pub(crate) fn is_hamiltonian_cycle<G: Graph>(graph: &G, selected: &[bool]) -> bo
 }
 
 crate::declare_variants! {
-    TravelingSalesman<SimpleGraph, i32> => "num_vertices!",
+    TravelingSalesman<SimpleGraph, i32> => "2^num_vertices",
 }
 
 #[cfg(test)]

src/models/optimization/closest_vector_problem.rs

@@ -173,8 +173,8 @@ where
 }
 
 crate::declare_variants! {
-    ClosestVectorProblem<i32> => "exp(num_basis_vectors)",
-    ClosestVectorProblem<f64> => "exp(num_basis_vectors)",
+    ClosestVectorProblem<i32> => "2^num_basis_vectors",
+    ClosestVectorProblem<f64> => "2^num_basis_vectors",
 }
 
 #[cfg(test)]

src/models/optimization/ilp.rs

@@ -377,7 +377,7 @@ impl OptimizationProblem for ILP {
 }
 
 crate::declare_variants! {
-    ILP => "exp(num_variables)",
+    ILP => "num_variables^num_variables",
 }
 
 #[cfg(test)]

src/models/satisfiability/ksat.rs

@@ -186,7 +186,7 @@ impl<K: KValue> SatisfactionProblem for KSatisfiability<K> {}
 crate::declare_variants! {
     KSatisfiability<KN> => "2^num_variables",
     KSatisfiability<K2> => "num_variables + num_clauses",
-    KSatisfiability<K3> => "2^num_variables",
+    KSatisfiability<K3> => "1.307^num_variables",
 }
 
 #[cfg(test)]

src/models/specialized/biclique_cover.rs

@@ -243,6 +243,10 @@ impl OptimizationProblem for BicliqueCover {
     }
 }
 
+crate::declare_variants! {
+    BicliqueCover => "2^num_vertices",
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/specialized/biclique_cover.rs"]
 mod tests;

src/models/specialized/bmf.rs

@@ -230,6 +230,10 @@ impl OptimizationProblem for BMF {
     }
 }
 
+crate::declare_variants! {
+    BMF => "2^(rows * rank + rank * cols)",
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/specialized/bmf.rs"]
 mod tests;

src/models/specialized/factoring.rs

@@ -163,7 +163,7 @@ impl OptimizationProblem for Factoring {
 }
 
 crate::declare_variants! {
-    Factoring => "exp(sqrt(num_bits))",
+    Factoring => "exp(num_bits^(1/3) * log(num_bits)^(2/3))",
 }
 
 #[cfg(test)]

src/models/specialized/paintshop.rs

@@ -192,6 +192,10 @@ impl OptimizationProblem for PaintShop {
     }
 }
 
+crate::declare_variants! {
+    PaintShop => "2^num_cars",
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/specialized/paintshop.rs"]
 mod tests;

src/unit_tests/rules/graph.rs

@@ -1082,7 +1082,7 @@ fn test_variant_complexity() {
     let graph = ReductionGraph::new();
     let variant = ReductionGraph::variant_to_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
     let complexity = graph.variant_complexity("MaximumIndependentSet", &variant);
-    assert_eq!(complexity, Some("2^num_vertices"));
+    assert_eq!(complexity, Some("1.1996^num_vertices"));
 
     // Unknown problem returns None
     let unknown = BTreeMap::new();