feat: One weight IS↔SP variants, fix complexity metadata, enrich paper (#106)

* feat: add One weight variant for IS↔SP reductions and cleanup dead APIs

- Add One weight variant for MaximumIndependentSet ↔ MaximumSetPacking
  reductions using local macros to keep impls DRY
- Register MaximumSetPacking<One> variant and add One→i32 weight cast
- Remove ConfigIterator (superseded by DimsIterator)
- Remove unused testing module (macros never adopted)
- Make LinearConstraint::new() pub(crate) (only le/ge/eq delegate to it)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: correct 7 variant complexities and 4 reduction overheads; enrich paper

Variant complexity fixes:
- MaximumMatching: 2^n → n^3 (polynomial by Edmonds' blossom)
- KColoring<K2>: 2^n → n+m (polynomial bipartiteness test)
- KColoring<K3>: 3^n → 1.3289^n (Beigel-Eppstein)
- KColoring<K4>: 4^n → 1.7159^n (Wu et al.)
- KColoring<K5>: 5^n → 2^n (Zamir)
- KColoring<KN>: k^n → 2^n (Björklund et al.)
- KSatisfiability<K2>: 2^n → n+m (Aspvall-Plass-Tarjan SCC)

Reduction overhead fixes:
- IS→SP: universe_size num_vertices → num_edges (sets contain edge indices)
- SP→IS: num_edges num_sets → num_sets^2 (intersection graph)
- SAT→kSAT: tighter clause/variable bounds for short-clause padding
- Factoring→CircuitSAT: 6 assignments + I/O vars per multiplier cell

Paper: remove standalone complexity table (Section 2.6), add
render-complexity inline in problem-def, enrich all 21 definitions
with algorithm context, limitations, and citations verified via
web search. Fix MaxClique bound (1.1892→1.1996 via MIS complement).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: address PR #106 review comments

- Fix KColoring K5 complexity: "2^num_vertices" -> "(2-epsilon)^num_vertices" (Zamir 2021)
- Fix Factoring->CircuitSAT num_assignments overhead to include output bit constraints
- Add tests for MaximumSetPacking variant cast reductions (One->i32, i32->f64)
- Regenerate reduction_graph.json with corrected metadata

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: GiggleLiu

.claude/CLAUDE.md

@@ -205,3 +205,19 @@ Also add to the `display-name` dictionary:
 ```
 
 Every directed reduction in the graph needs its own `reduction-rule` entry. The paper auto-checks completeness against `reduction_graph.json`.
+
+## Complexity Verification Requirements
+
+### Variant Worst-Case Complexity (`declare_variants!`)
+The complexity string represents the **worst-case time complexity of the best known algorithm** for that problem variant. To verify correctness:
+1. Identify the best known exact algorithm for the problem (name, author, year, citation)
+2. Confirm the worst-case time bound from the original paper or a survey
+3. Check that polynomial-time problems (e.g., MaximumMatching, 2-SAT, 2-Coloring) are NOT declared with exponential complexity
+4. For NP-hard problems, verify the base of the exponential matches the literature (e.g., 1.1996^n for MIS, not 2^n)
+
+### Reduction Overhead (`#[reduction(overhead = {...})]`)
+Overhead expressions describe how target problem size relates to source problem size. To verify correctness:
+1. Read the `reduce_to()` implementation and count the actual output sizes
+2. Check that each field (e.g., `num_vertices`, `num_edges`, `num_sets`) matches the constructed target problem
+3. Watch for common errors: universe elements mismatch (edge indices vs vertex indices), worst-case edge counts in intersection graphs (quadratic, not linear), constant factors in circuit constructions
+4. Test with concrete small instances: construct a source problem, run the reduction, and compare target sizes against the formula

docs/paper/reductions.typ

@@ -85,6 +85,24 @@
   }
 }
 
+// Render complexity from graph-data nodes
+#let render-complexity(name) = {
+  let nodes = graph-data.nodes.filter(n => n.name == name)
+  if nodes.len() == 0 { return }
+  let seen = ()
+  let entries = ()
+  for node in nodes {
+    if node.complexity not in seen {
+      seen.push(node.complexity)
+      entries.push(node.complexity)
+    }
+  }
+  block(above: 0.5em)[
+    #set text(size: 9pt)
+    - Complexity: #entries.map(e => raw(e)).join("; ").
+  ]
+}
+
 // Render the "Reduces to/from" lines for a problem
 #let render-reductions(problem-name) = {
   let reduces-to = get-reductions-to(problem-name)
@@ -158,13 +176,14 @@
   base_level: 1,
 )
 
-// Problem definition wrapper: auto-adds schema, reductions list, and label
+// Problem definition wrapper: auto-adds schema, complexity, reductions list, and label
 #let problem-def(name, body) = {
   let lbl = label("def:" + name)
   let title = display-name.at(name)
   [#definition(title)[
     #body
     #render-schema(name)
+    #render-complexity(name)
     #render-reductions(name)
   ] #lbl]
 }
@@ -309,95 +328,116 @@ 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. Best known: $O^*(1.1996^n)$ via measure-and-conquer branching @xiao2017. Solvable in polynomial time on bipartite, interval, and cograph classes.
 ]
 
 #problem-def("MinimumVertexCover")[
   Given $G = (V, E)$ with vertex weights $w: V -> RR$, find $S subset.eq V$ minimizing $sum_(v in S) w(v)$ such that every edge has at least one endpoint in $S$: $forall (u, v) in E: u in S or v in S$.
+  Best known: $O^*(1.1996^n)$ via MIS complement ($|"VC"| + |"IS"| = n$) @xiao2017. A central problem in parameterized complexity: admits FPT algorithms in $O^*(1.2738^k)$ time parameterized by solution size $k$.
 ]
 
 #problem-def("MaxCut")[
   Given $G = (V, E)$ with weights $w: E -> RR$, find partition $(S, overline(S))$ maximizing $sum_((u,v) in E: u in S, v in overline(S)) w(u, v)$.
+  Best known: $O^*(2^(omega n slash 3))$ via algebraic 2-CSP techniques @williams2005, where $omega < 2.372$ is the matrix multiplication exponent; requires exponential space. Polynomial-time solvable on planar graphs. The Goemans-Williamson SDP relaxation achieves a 0.878-approximation @goemans1995.
 ]
 
 #problem-def("KColoring")[
   Given $G = (V, E)$ and $k$ colors, find $c: V -> {1, ..., k}$ minimizing $|{(u, v) in E : c(u) = c(v)}|$.
+  Deciding $k$-colorability is NP-complete for $k >= 3$ @garey1979. Best known: $O(n+m)$ for $k=2$ (equivalent to bipartiteness testing by BFS); $O^*(1.3289^n)$ for $k=3$ @beigel2005; $O^*(1.7159^n)$ for $k=4$ @wu2024; $O^*((2-epsilon)^n)$ for $k=5$, the first to break the $2^n$ barrier @zamir2021; $O^*(2^n)$ in general via inclusion-exclusion over independent sets @bjorklund2009.
 ]
 
 #problem-def("MinimumDominatingSet")[
   Given $G = (V, E)$ with weights $w: V -> RR$, find $S subset.eq V$ minimizing $sum_(v in S) w(v)$ s.t. $forall v in V: v in S or exists u in S: (u, v) in E$.
+  Best known: $O^*(1.4969^n)$ via branch-and-reduce with measure and conquer @vanrooij2011. W[2]-complete when parameterized by solution size, making it strictly harder than Vertex Cover in the parameterized hierarchy.
 ]
 
 #problem-def("MaximumMatching")[
   Given $G = (V, E)$ with weights $w: E -> RR$, find $M subset.eq E$ maximizing $sum_(e in M) w(e)$ s.t. $forall e_1, e_2 in M: e_1 inter e_2 = emptyset$.
+  Solvable in polynomial time $O(n^3)$ by Edmonds' blossom algorithm @edmonds1965, which introduced the technique of shrinking odd cycles into pseudo-nodes. Unlike most combinatorial optimization problems on general graphs, maximum matching is not NP-hard.
 ]
 
 #problem-def("TravelingSalesman")[
   Given an undirected graph $G=(V,E)$ with edge weights $w: E -> RR$, find an edge set $C subset.eq E$ that forms a cycle visiting every vertex exactly once and minimizes $sum_(e in C) w(e)$.
+  Best known: $O^*(2^n)$ via Held-Karp dynamic programming @heldkarp1962, requiring $O^*(2^n)$ space. No $O^*((2-epsilon)^n)$ time algorithm is known.
 ]
 
 #problem-def("MaximumClique")[
   Given $G = (V, E)$, find $K subset.eq V$ maximizing $|K|$ such that all pairs in $K$ are adjacent: $forall u, v in K: (u, v) in E$. Equivalent to MIS on the complement graph $overline(G)$.
+  Best known: $O^*(1.1996^n)$ via complement reduction to MIS @xiao2017. Robson's direct algorithm achieves $O^*(1.2109^n)$ @robson1986 using exponential space.
 ]
 
 #problem-def("MaximalIS")[
   Given $G = (V, E)$ with vertex weights $w: V -> RR$, find $S subset.eq V$ maximizing $sum_(v in S) w(v)$ such that $S$ is independent ($forall u, v in S: (u, v) in.not E$) and maximal (no vertex $u in V backslash S$ can be added to $S$ while maintaining independence).
+  Best known: $O^*(3^(n slash 3))$ for enumerating all maximal independent sets @tomita2006. This bound is tight: Moon and Moser @moonmoser1965 showed that every $n$-vertex graph has at most $3^(n slash 3)$ maximal independent sets, achieved by disjoint triangles.
 ]
 
 
 == Set Problems
 
 #problem-def("MaximumSetPacking")[
   Given universe $U$, collection $cal(S) = {S_1, ..., S_m}$ with $S_i subset.eq U$, weights $w: cal(S) -> RR$, find $cal(P) subset.eq cal(S)$ maximizing $sum_(S in cal(P)) w(S)$ s.t. $forall S_i, S_j in cal(P): S_i inter S_j = emptyset$.
+  One of Karp's 21 NP-complete problems @karp1972. Generalizes maximum matching (the special case where all sets have size 2, solvable in polynomial time). The optimization version is as hard to approximate as maximum clique. Best known: $O^*(2^m)$.
 ]
 
 #problem-def("MinimumSetCovering")[
   Given universe $U$, collection $cal(S)$ with weights $w: cal(S) -> RR$, find $cal(C) subset.eq cal(S)$ minimizing $sum_(S in cal(C)) w(S)$ s.t. $union.big_(S in cal(C)) S = U$.
+  Best known: $O^*(2^m)$. The greedy algorithm achieves an $O(ln n)$-approximation where $n = |U|$, which is essentially optimal: cannot be approximated within $(1-o(1)) ln n$ unless P = NP.
 ]
 
 == Optimization Problems
 
 #problem-def("SpinGlass")[
   Given $n$ spin variables $s_i in {-1, +1}$, pairwise couplings $J_(i j) in RR$, and external fields $h_i in RR$, minimize the Hamiltonian (energy function): $H(bold(s)) = -sum_((i,j)) J_(i j) s_i s_j - sum_i h_i s_i$.
+  NP-hard on general graphs @barahona1982; best known $O^*(2^n)$. On planar graphs without external field ($h_i = 0$), solvable in polynomial time via reduction to minimum-weight perfect matching. Central to statistical physics and quantum computing.
 ]
 
 #problem-def("QUBO")[
   Given $n$ binary variables $x_i in {0, 1}$, upper-triangular matrix $Q in RR^(n times n)$, minimize $f(bold(x)) = sum_(i=1)^n Q_(i i) x_i + sum_(i < j) Q_(i j) x_i x_j$ (using $x_i^2 = x_i$ for binary variables).
+  Equivalent to the Ising model via the linear substitution $s_i = 2x_i - 1$. The native formulation for quantum annealing hardware and a standard target for penalty-method reductions @glover2019. Best known: $O^*(2^n)$.
 ]
 
 #problem-def("ILP")[
   Given $n$ integer variables $bold(x) in ZZ^n$, constraint matrix $A in RR^(m times n)$, bounds $bold(b) in RR^m$, and objective $bold(c) in RR^n$, find $bold(x)$ minimizing $bold(c)^top bold(x)$ subject to $A bold(x) <= bold(b)$ and variable bounds.
+  Best known: $O^*(n^n)$ @dadush2012. When the number of integer variables $n$ is fixed, solvable in polynomial time by Lenstra's algorithm @lenstra1983 using the geometry of numbers, making ILP fixed-parameter tractable in $n$.
 ]
 
 == Satisfiability Problems
 
 #problem-def("Satisfiability")[
   Given a CNF formula $phi = and.big_(j=1)^m C_j$ with $m$ clauses over $n$ Boolean variables, where each clause $C_j = or.big_i ell_(j i)$ is a disjunction of literals, find an assignment $bold(x) in {0, 1}^n$ such that $phi(bold(x)) = 1$ (all clauses satisfied).
+  Best known: $O^*(2^n)$. The Strong Exponential Time Hypothesis (SETH) @impagliazzo2001 conjectures that no $O^*((2-epsilon)^n)$ algorithm exists for general CNF-SAT. Despite this worst-case hardness, conflict-driven clause learning (CDCL) solvers handle large practical instances efficiently.
 ]
 
 #problem-def("KSatisfiability")[
   SAT with exactly $k$ literals per clause.
+  $O(n+m)$ for $k=2$ via implication graph SCC decomposition @aspvall1979. $O^*(1.307^n)$ for $k=3$ via biased-PPSZ @hansen2019. Under SETH, $k$-SAT requires time $O^*(c_k^n)$ with $c_k -> 2$ as $k -> infinity$.
 ]
 
 #problem-def("CircuitSAT")[
   Given a Boolean circuit $C$ composed of logic gates (AND, OR, NOT, XOR) with $n$ input variables, find an input assignment $bold(x) in {0,1}^n$ such that $C(bold(x)) = 1$.
+  NP-complete by the Cook-Levin theorem @cook1971, which established NP-completeness by showing any NP computation can be expressed as a boolean circuit. Reducible to CNF-SAT via the Tseitin transformation. Best known: $O^*(2^n)$.
 ]
 
 #problem-def("Factoring")[
   Given a composite integer $N$ and bit sizes $m, n$, find integers $p in [2, 2^m - 1]$ and $q in [2, 2^n - 1]$ such that $p times q = N$. Here $p$ has $m$ bits and $q$ has $n$ bits.
+  Sub-exponential classically: $e^(O(b^(1 slash 3)(log b)^(2 slash 3)))$ via the General Number Field Sieve @lenstra1993, where $b$ is the bit length. Solvable in polynomial time on a quantum computer by Shor's algorithm @shor1994. Not known to be NP-complete; factoring lies in NP $inter$ co-NP.
 ]
 
 == Specialized Problems
 
 #problem-def("BMF")[
   Given an $m times n$ boolean matrix $A$ and rank $k$, find boolean matrices $B in {0,1}^(m times k)$ and $C in {0,1}^(k times n)$ minimizing the Hamming distance $d_H (A, B circle.tiny C)$, where the boolean product $(B circle.tiny C)_(i j) = or.big_ell (B_(i ell) and C_(ell j))$.
+  NP-hard, even to approximate. Arises in data mining, text mining, and recommender systems. Best known: $O^*(2^n)$; practical algorithms use greedy rank-1 extraction.
 ]
 
 #problem-def("PaintShop")[
   Given a sequence of $2n$ positions where each of $n$ cars appears exactly twice, assign a binary color to each car (each car's two occurrences receive opposite colors) to minimize the number of color changes between consecutive positions.
+  NP-hard and APX-hard @epping2004. Arises in automotive manufacturing where color changes require setup time and increase paint waste. A natural benchmark for quantum annealing. Best known: $O^*(2^n)$.
 ]
 
 #problem-def("BicliqueCover")[
   Given a bipartite graph $G = (L, R, E)$ and integer $k$, find $k$ bicliques $(L_1, R_1), dots, (L_k, R_k)$ that cover all edges ($E subset.eq union.big_i L_i times R_i$) while minimizing the total size $sum_i (|L_i| + |R_i|)$.
+  NP-hard; connected to the Boolean rank of binary matrices and nondeterministic communication complexity. Best known: $O^*(2^n)$.
 ]
 
 // Completeness check: warn about problem types in JSON but missing from paper

docs/paper/references.bib

@@ -80,6 +80,164 @@ @article{nguyen2023
   doi     = {10.1103/PRXQuantum.4.010316}
 }
 
+@article{xiao2017,
+  author  = {Mingyu Xiao and Hiroshi Nagamochi},
+  title   = {Exact Algorithms for Maximum Independent Set},
+  journal = {Information and Computation},
+  volume  = {255},
+  pages   = {126--146},
+  year    = {2017},
+  doi     = {10.1016/j.ic.2017.06.001}
+}
+
+@article{robson1986,
+  author  = {J. M. Robson},
+  title   = {Algorithms for Maximum Independent Sets},
+  journal = {Journal of Algorithms},
+  volume  = {7},
+  number  = {3},
+  pages   = {425--440},
+  year    = {1986},
+  doi     = {10.1016/0196-6774(86)90032-5}
+}
+
+@article{vanrooij2011,
+  author  = {Johan M. M. van Rooij and Hans L. Bodlaender},
+  title   = {Exact algorithms for dominating set},
+  journal = {Discrete Applied Mathematics},
+  volume  = {159},
+  number  = {17},
+  pages   = {2147--2164},
+  year    = {2011},
+  doi     = {10.1016/j.dam.2011.07.001}
+}
+
+@article{williams2005,
+  author  = {Ryan Williams},
+  title   = {A new algorithm for optimal 2-constraint satisfaction and its implications},
+  journal = {Theoretical Computer Science},
+  volume  = {348},
+  number  = {2--3},
+  pages   = {357--365},
+  year    = {2005},
+  doi     = {10.1016/j.tcs.2005.09.023}
+}
+
+@article{tomita2006,
+  author  = {Etsuji Tomita and Akira Tanaka and Haruhisa Takahashi},
+  title   = {The worst-case time complexity for generating all maximal cliques and computational experiments},
+  journal = {Theoretical Computer Science},
+  volume  = {363},
+  number  = {1},
+  pages   = {28--42},
+  year    = {2006},
+  doi     = {10.1016/j.tcs.2006.06.015}
+}
+
+@article{heldkarp1962,
+  author  = {Michael Held and Richard M. Karp},
+  title   = {A Dynamic Programming Approach to Sequencing Problems},
+  journal = {Journal of the Society for Industrial and Applied Mathematics},
+  volume  = {10},
+  number  = {1},
+  pages   = {196--210},
+  year    = {1962},
+  doi     = {10.1137/0110015}
+}
+
+@article{beigel2005,
+  author  = {Richard Beigel and David Eppstein},
+  title   = {3-Coloring in Time {$O(1.3289^n)$}},
+  journal = {Journal of Algorithms},
+  volume  = {54},
+  number  = {2},
+  pages   = {168--204},
+  year    = {2005},
+  doi     = {10.1016/j.jalgor.2004.06.008}
+}
+
+@inproceedings{wu2024,
+  author    = {Pu Wu and Huanyu Gu and Huiqin Jiang and Zehui Shao and Jin Xu},
+  title     = {A Faster Algorithm for the 4-Coloring Problem},
+  booktitle = {European Symposium on Algorithms (ESA)},
+  series    = {LIPIcs},
+  volume    = {308},
+  pages     = {103:1--103:16},
+  year      = {2024},
+  doi       = {10.4230/LIPIcs.ESA.2024.103}
+}
+
+@inproceedings{zamir2021,
+  author    = {Or Zamir},
+  title     = {Breaking the {$2^n$} Barrier for 5-Coloring and 6-Coloring},
+  booktitle = {International Colloquium on Automata, Languages, and Programming (ICALP)},
+  series    = {LIPIcs},
+  volume    = {198},
+  pages     = {113:1--113:20},
+  year      = {2021},
+  doi       = {10.4230/LIPIcs.ICALP.2021.113}
+}
+
+@article{bjorklund2009,
+  author  = {Andreas Bj\"{o}rklund and Thore Husfeldt and Mikko Koivisto},
+  title   = {Set Partitioning via Inclusion-Exclusion},
+  journal = {SIAM Journal on Computing},
+  volume  = {39},
+  number  = {2},
+  pages   = {546--563},
+  year    = {2009},
+  doi     = {10.1137/070683933}
+}
+
+@article{aspvall1979,
+  author  = {Bengt Aspvall and Michael F. Plass and Robert Endre Tarjan},
+  title   = {A Linear-Time Algorithm for Testing the Truth of Certain Quantified Boolean Formulas},
+  journal = {Information Processing Letters},
+  volume  = {8},
+  number  = {3},
+  pages   = {121--123},
+  year    = {1979},
+  doi     = {10.1016/0020-0190(79)90002-4}
+}
+
+@inproceedings{hansen2019,
+  author    = {Thomas Dueholm Hansen and Haim Kaplan and Or Zamir and Uri Zwick},
+  title     = {Faster $k$-{SAT} Algorithms Using Biased-{PPSZ}},
+  booktitle = {Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC)},
+  pages     = {578--589},
+  year      = {2019},
+  doi       = {10.1145/3313276.3316359}
+}
+
+@phdthesis{dadush2012,
+  author = {Daniel Dadush},
+  title  = {Integer Programming, Lattice Algorithms, and Deterministic Volume Estimation},
+  school = {Georgia Institute of Technology},
+  year   = {2012}
+}
+
+@incollection{lenstra1993,
+  author    = {Arjen K. Lenstra and Hendrik W. Lenstra and Mark S. Manasse and John M. Pollard},
+  title     = {The Number Field Sieve},
+  booktitle = {The Development of the Number Field Sieve},
+  publisher = {Springer},
+  series    = {Lecture Notes in Mathematics},
+  volume    = {1554},
+  year      = {1993},
+  doi       = {10.1007/BFb0091539}
+}
+
+@inproceedings{impagliazzo2001,
+  author    = {Russell Impagliazzo and Ramamohan Paturi and Francis Zane},
+  title     = {Which Problems Have Strongly Exponential Complexity?},
+  booktitle = {Journal of Computer and System Sciences},
+  volume    = {63},
+  number    = {4},
+  pages     = {512--530},
+  year      = {2001},
+  doi       = {10.1006/jcss.2001.1774}
+}
+
 @article{pan2025,
   author  = {Xi-Wei Pan and Huan-Hai Zhou and Yi-Ming Lu and Jin-Guo Liu},
   title   = {Encoding computationally hard problems in triangular {R}ydberg atom arrays},
@@ -89,3 +247,56 @@ @article{pan2025
   archivePrefix = {arXiv}
 }
 
+@article{goemans1995,
+  author  = {Michel X. Goemans and David P. Williamson},
+  title   = {Improved Approximation Algorithms for Maximum Cut and Satisfiability Problems Using Semidefinite Programming},
+  journal = {Journal of the ACM},
+  volume  = {42},
+  number  = {6},
+  pages   = {1115--1145},
+  year    = {1995},
+  doi     = {10.1145/227683.227684}
+}
+
+@inproceedings{shor1994,
+  author    = {Peter W. Shor},
+  title     = {Algorithms for Quantum Computation: Discrete Logarithms and Factoring},
+  booktitle = {Proceedings of the 35th Annual Symposium on Foundations of Computer Science (FOCS)},
+  pages     = {124--134},
+  year      = {1994},
+  doi       = {10.1109/SFCS.1994.365700}
+}
+
+@article{moonmoser1965,
+  author  = {J. W. Moon and L. Moser},
+  title   = {On cliques in graphs},
+  journal = {Israel Journal of Mathematics},
+  volume  = {3},
+  number  = {1},
+  pages   = {23--28},
+  year    = {1965},
+  doi     = {10.1007/BF02760024}
+}
+
+@inproceedings{lenstra1983,
+  author    = {Hendrik W. Lenstra},
+  title     = {Integer Programming with a Fixed Number of Variables},
+  booktitle = {Mathematics of Operations Research},
+  volume    = {8},
+  number    = {4},
+  pages     = {538--548},
+  year      = {1983},
+  doi       = {10.1287/moor.8.4.538}
+}
+
+@article{epping2004,
+  author  = {Thomas Epping and Winfried Hochst\"{a}ttler and Peter Oertel},
+  title   = {Complexity results on a paint shop problem},
+  journal = {Discrete Applied Mathematics},
+  volume  = {136},
+  number  = {2--3},
+  pages   = {217--226},
+  year    = {2004},
+  doi     = {10.1016/S0166-218X(03)00442-6}
+}
+