## 1. Introduction

Integer Linear Programming (

ILP) is among the most successful and general paradigms for solving computationally intractable optimization problems in computer science. In particular, a wide variety of problems in areas such as process scheduling [

1], planning [

2,

3], vehicle routing [

4], packing [

5], and network hub location [

6], to name a few, are efficiently solved in practice via a translation into an Integer Linear Program.

ILP is

**NP**-complete, and a significant amount of research has been carried out on tractable fragments of ILP defined in terms of the algebraic properties of the instance (see, e.g., the work of Papadimitriou and Steiglitz exploiting total unimodularity (Section 13.2, [

7])) or in terms of restrictions on the number of constraints or variables (see Lenstra’s algorithm [

8] together with its subsequent improvements by Kannan [

9], Frank and Tardos [

10]).

On the other hand, until recently we have lacked a systematic study of the complexity of

ILP through the lens of variable-constraint interactions. This represented a stark contrast to our understanding of other fundamental problems such as

Boolean Satisfiability and

Constraint Satisfaction, where we have classical results that explore and showcase how interactions between variables and constraints (formalized via graphical representations) can be used to define natural tractable fragments of the problem—consider, e.g., the early work of Freuder [

11], Dechter and Pearl [

12]. The situation for

ILP changed drastically in recent years thanks to a flurry of results that together lay out a detailed complexity landscape for the problem centered around variable-constraint interactions, captured in terms of graphical representations of instances. The aim of this survey is to summarize these recent developments, put them into context and a unified format, and make them more approachable for experts from many diverse backgrounds. We will also call attention to prominent open problems in the area.

**Survey Organization.** After introducing some basic preliminaries for ILPs, graphical representations and structural parameters in

Section 2,

Section 3 proceeds to a brief overview of classical algorithms for ILP that rely on explicit restrictions such as bounds on the number of variables and/or constraints. In

Section 4 we focus on algorithms and lower bounds for ILP that target instances whose variable-constraint interactions give rise to graphical representations of bounded treewidth and/or treedepth.

Section 5 then covers results utilizing other structural parameters related to variable-constraint interactions, and the final

Section 6 provides an outlook to future work in the area.

## 2. Preliminaries

For a positive integer n, we use $\left[n\right]$ to denote the set $\{1,\dots ,n\}$. We use bold face letters for vectors and normal font when referring to their components, that is, $\mathbf{x}$ is a vector and ${x}_{3}$ is its third component.

#### 2.1. Graphs

We use standard graph terminology, see for instance Diestel’s handbook [

13]. A graph

G is a tuple

$(V,E)$, where

V or

$V\left(G\right)$ is the vertex set and

E or

$E\left(G\right)$ is the edge set. A graph

H is a subgraph of a graph

G, denoted

$H\subseteq G$, if

H can be obtained by deleting vertices and edges from

G. All our graphs are simple and loopless.

A path from vertex v to vertex w in G is a sequence of pairwise distinct vertices ${v}_{1},\dots ,{v}_{j}$ of G such that $v={v}_{1}$ and $w={v}_{j}$ and $\{{v}_{i},{v}_{i+1}\}\in E\left(G\right)$ for every i with $1\le i<j$; and we define the length of a path to be equal the number of vertices it contains (i.e., j). A tree is a graph in which, for any two vertices $v,w\in G$, there is precisely one unique path from v to w; a tree is rooted if it contains a specially designated vertex r, the root. Given a vertex v in a tree G with root r, the parent of v is the unique vertex w with the property that $\{v,w\}$ is the first edge on the path from v to r.

#### 2.2. Integer Linear Programming

We consider instances of Integer Linear Programming (

ILP) in the following two normal forms. In the first case, which we call the equality normal form, instances consist of a matrix

$A\in {\mathbb{Z}}^{m\times n}$ with

m rows (constraints) and

n columns (variables) and vectors

$\mathbf{c},\mathbf{b}\in {\mathbb{Z}}^{m}$,

$\mathbf{l},\mathbf{u}\in {\mathbb{Z}}^{n}\cup \{\infty ,-\infty \}$. The set of solutions for the equality normal form is given by:

In the second case, which we call the inequality normal form, instances consist of a matrix

$A\in {\mathbb{Z}}^{m\times n}$ with

m rows (constraints) and

n columns (variables) and vectors

$\mathbf{c},\mathbf{b}\in {\mathbb{Z}}^{m}$. Here, the set of solutions is given by:

We denote by ILPF${}_{=}$ and ILPF${}_{\le}$ the feasibility problem for ILPs, whose sets of solutions are given in the equality respectively the inequality form, e.g., ILPF${}_{=}$ is the problem of deciding whether $\left\{\phantom{\rule{0.166667em}{0ex}}\mathbf{y}\phantom{\rule{0.277778em}{0ex}}\right|\phantom{\rule{0.277778em}{0ex}}A\mathbf{y}=\mathbf{b},\phantom{\rule{0.166667em}{0ex}}\mathbf{l}\le \mathbf{y}\le \mathbf{u}\phantom{\rule{0.166667em}{0ex}}\}$ is non-empty and if so to output a vector $\mathbf{y}$ in $\left\{\phantom{\rule{0.166667em}{0ex}}\mathbf{y}\phantom{\rule{0.277778em}{0ex}}\right|\phantom{\rule{0.277778em}{0ex}}A\mathbf{y}=\mathbf{b},\phantom{\rule{0.166667em}{0ex}}\mathbf{l}\le \mathbf{y}\le \mathbf{u}\phantom{\rule{0.166667em}{0ex}}\}$. Moreover, ILP${}_{=}$ and ILP${}_{\le}$ denote the corresponding minimization versions, e.g., ILP${}_{=}$ is the problem of deciding whether $\mathbf{y}\in \left\{\phantom{\rule{0.166667em}{0ex}}\mathbf{y}\phantom{\rule{0.277778em}{0ex}}\right|\phantom{\rule{0.277778em}{0ex}}A\mathbf{y}=\mathbf{b},\phantom{\rule{0.166667em}{0ex}}\mathbf{l}\le \mathbf{y}\le \mathbf{u}\phantom{\rule{0.166667em}{0ex}}\}$ contains a vector $\mathbf{y}$ that minimizes $\mathbf{c}\mathbf{y}$ and if so outputs such a vector.

For the matrix A of an instance $\mathcal{I}$, we let $\mathbf{x}=({x}_{1},\dots ,{x}_{n})$ be a vector representing the columns in A and let the variable set, denoted $\mathrm{var}\left(\mathcal{I}\right)$, be the set of such columns. If $\mathcal{I}$ is given in equality normal form, then its constraint set denoted by $\mathrm{con}\left(\mathcal{I}\right)$ contains one equation for every equation in the system $A\mathbf{x}=\mathbf{b}$ respectively one inequality for every inequality in the system $A\mathbf{x}\le \mathbf{b}$, if $\mathcal{I}$ is given in inequality normal form.

We will also make use of the following notions which describe specific properties of ILP instances. We denote by ${\parallel A\parallel}_{\infty}$, $\parallel \mathbf{b}\parallel $, and $\parallel \mathbf{c}\parallel $ the maximum absolute value of any coefficient (entry) in the matrix A, in the vector $\mathbf{b}$, and in the vector $\mathbf{c}$, respectively.

For an ILP instance $\mathcal{I}$ in inequality form, we say that the domain of the variable ${x}_{i}$ is bounded if there are constraints p and r of the form ${x}_{i}\le {b}_{p}$ and $-{x}_{i}\le {b}_{r}$, otherwise we say that its domain is unbounded. Moreover, we denote by $\parallel {x}_{i}\parallel $ the maximum domain span of the i-th variable, i.e., given by $\parallel {b}_{p}-{b}_{r}\parallel $ if ${x}_{i}$ has bounded domain and ∞ otherwise. We denote by ${\parallel \mathbf{x}\parallel}_{\infty}$ the maximum domain span of any variable, i.e., ${max}_{i}\parallel {x}_{i}\parallel $. On the other hand, if $\mathcal{I}$ is in equality form, we say that the domain of the i-th variable ${x}_{i}$ is bounded if ${l}_{i},{u}_{i}\notin \{-\infty ,\infty \}$, where ${l}_{i},{u}_{i}$ are the i-th entries of $\mathbf{l}$, $\mathbf{u}$, respectively; otherwise, we say that the domain of $\mathbf{x}$ is unbounded. Moreover, we denote by $\parallel {x}_{i}\parallel $ the maximum domain span of the i-th variable, i.e., $\parallel {u}_{i}-{l}_{i}\parallel $ any variable, and by ${\parallel \mathbf{x}\parallel}_{\infty}$ the maximum domain span of any variable, i.e., ${max}_{i}\parallel {x}_{i}\parallel $.

In either case, we say that an ILP instance has bounded domain if all variables have bounded domain, and we say that the instance has unary bounded domain if the coefficients bounding the domain of variables are encoded in unary.

Finally, we call an ILP instance unary if all coefficients in A, $\mathbf{b}$, $\mathbf{c}$, as well as $\mathbf{l}$, $\mathbf{u}$ (if they are part of the input) are given in unary. We say that an ILP instance is fully unary if it is unary and all variables have (unary) bounded domain.

#### 2.3. Parameterized Complexity

In parameterized algorithmics [

14,

15,

16,

17] the runtime of an algorithm is studied with respect to a parameter

$k\in \mathbb{N}$ and input size

n. The basic idea is to find a parameter that describes the structure of the instance such that the combinatorial explosion can be confined to this parameter. In this respect, the most favorable complexity class is

**FPT** (

fixed-parameter tractable) which contains all problems that can be decided by an algorithm running in time

$f\left(k\right)\xb7{n}^{\mathcal{O}\left(1\right)}$, where

f is a computable function. Algorithms with this running time are called

fpt-algorithms.

There is a variety of classes capturing

parameterized intractability. Here we require only the class

**paraNP**, which is defined as the class of problems that are solvable by a nondeterministic Turing-machine in fpt-time. We will make use of the characterization of

**paraNP**-hardness given by Flum and Grohe (Theorem 2.14, [

15]): any parameterized (decision) problem that remains

**NP**-hard when the parameter is set to some constant is

**paraNP**-hard. Showing

**paraNP**-hardness for a problem rules out the existence of an fpt-algorithm under the assumption that

$\mathbf{P}\ne \mathbf{NP}$. In fact, it even allows us to rule out algorithms running in time

${n}^{f\left(k\right)}$ for any function

f (these are called

XP algorithms).

#### 2.4. Graph Parameters

**Treewidth.** Treewidth is the most prominent structural parameter and has been extensively studied in a number of fields. In order to define treewidth, we begin with the definition of its associated decomposition. A tree-decomposition $\mathcal{T}$ of a graph $G=(V,E)$ is a pair $(T,\chi )$, where T is a tree and $\chi $ is a function that assigns each tree node t a set $\chi \left(t\right)\subseteq V$ of vertices such that the following conditions hold:

- (T1)
For every edge $\{u,v\}\in E\left(G\right)$ there is a tree node t such that $u,v\in \chi \left(t\right)$.

- (T2)
For every vertex $v\in V\left(G\right)$, the set of tree nodes t with $v\in \chi \left(t\right)$ forms a non-empty subtree of T.

The sets $\chi \left(t\right)$ are called bags of the decomposition $\mathcal{T}$ and $\chi \left(t\right)$ is the bag associated with the tree node t. The width of a tree-decomposition $(T,\chi )$ is the size of a largest bag minus 1. A tree-decomposition of minimum width is called optimal. The treewidth of a graph G, denoted by $\mathrm{tw}\left(G\right)$, is the width of an optimal tree decomposition of G.

**Proposition** **1** ([

18,

19,

20])

**.** It is possible to compute an optimal tree-decomposition of an n-vertex graph G with treewidth k in time ${k}^{\mathcal{O}\left({k}^{3}\right)}n$, and to compute a 5-approximate one in time ${2}^{\mathcal{O}\left(k\right)}n$. Moreover, the number of nodes in the obtained tree decompositions is at most $\mathcal{O}\left(n\right)$.**Treedepth.** Another important notion that we make use of extensively is that of treedepth. Treedepth is a structural parameter closely related to treewidth, and the structure of graphs of bounded treedepth is well understood [

21]. A useful way of thinking about graphs of bounded treedepth is that they are (sparse) graphs with no long paths.

We formalize a few notions needed to define treedepth. A rooted forest is a disjoint union of rooted trees. For a vertex x in a tree T of a rooted forest, the height (or depth) of x in the forest is the number of vertices in the path from the root of T to x. The height of a rooted forest is the maximum height of a vertex of the forest.

**Definition** **1** (Treedepth)

**.** Let the closure of a rooted forest $\mathcal{F}$ be the graph $clos\left(\mathcal{F}\right)=({V}_{c},{E}_{c})$ with the vertex set ${V}_{c}={\bigcup}_{T\in \mathcal{F}}V\left(T\right)$ and the edge set ${E}_{c}=\{xy:x\phantom{\rule{4.pt}{0ex}}is\phantom{\rule{4.pt}{0ex}}an\phantom{\rule{4.pt}{0ex}}ancestor\phantom{\rule{4.pt}{0ex}}of\phantom{\rule{4.pt}{0ex}}y\phantom{\rule{4.pt}{0ex}}in\phantom{\rule{4.pt}{0ex}}some\phantom{\rule{4.pt}{0ex}}T\in \mathcal{F}\}$. A treedepth decomposition of a graph G is a rooted forest $\mathcal{F}$ such that $G\subseteq clos\left(\mathcal{F}\right)$. The treedepth $\mathrm{td}\left(G\right)$ of a graph G is the minimum height of any treedepth decomposition of G.

We will later use ${T}_{x}$ to denote the vertex set of the subtree of T rooted at a vertex x of T. Similarly to treewidth, it is possible to determine the treedepth of a graph in FPT time.

**Proposition** **2** ([

21])

**.** Given a graph G with n nodes and a constant w, it is possible to decide whether G has treedepth at most w, and if so, to compute an optimal treedepth decomposition of G in time $\mathcal{O}n$.The following alternative (equivalent) characterization of treedepth will be useful later.

**Proposition** **3** ([

21])

**.** Let ${G}_{i}$ be the connected components of G. ThenWe conclude with a few useful facts about treedepth.

**Proposition** **4** If a graph G has no path of length d, then $\mathrm{td}\left(G\right)\le d$.

If $\mathrm{td}\left(G\right)\le d$, then G has no path of length ${2}^{d}$.

$\mathrm{tw}\left(G\right)\le \mathrm{td}\left(G\right)$.

If $\mathrm{td}\left(G\right)\le d$, then $\mathrm{td}\left({G}^{\prime}\right)\le d+1$ for any graph ${G}^{\prime}$ obtained by adding one vertex into G.

**(Signed) Clique-width.** Let k be a positive integer. A k-graph is a graph whose vertices are labeled by $\left[k\right]$; formally, the graph is equipped with a labeling function $\gamma :V\left(G\right)\to \left[k\right]$, and we also use ${\gamma}^{-1}\left(i\right)$ to denote the set of vertices labeled i for $i\in \left[k\right]$.

We consider an arbitrary graph as a k-graph with all vertices labeled by 1. We call the k-graph consisting of exactly one vertex v (say, labeled by i) an initial k-graph and denote it by $i\left(v\right)$. The clique-width of a graph G is the smallest integer k such that G can be constructed from initial k-graphs by means of repeated application of the following three operations:

Disjoint union (denoted by ⊕);

Relabeling: changing all labels i to j (denoted by ${p}_{i\to j}$);

Edge insertion: adding an edge between each vertex labeled by i and each vertex labeled by j, where $i\ne j$ (denoted by ${\eta}_{i,j}$ or ${\eta}_{j,i}$).

A construction of a k-graph G using the above operations can be represented by an algebraic term composed of ⊕, ${p}_{i\to j}$ and ${\eta}_{i,j}$ (where $i\ne j$ and $i,j\in \left[k\right]$). Such a term is called a k-expression defining G, and the clique-width of G is the smallest integer k such that G can be defined by a k-expression.

A

k-expression tree (also called parse trees in the literature [

22]) is a rooted tree representation of a

k-expression; specifically, the

k-expression tree can be built from a

k-expression in a leaves-to-root fashion by using a leaf to represent each

$i\left(v\right)$, each ⊕ operator is represented by an ⊕ node with two children, and each

${p}_{i\to j}$ and

${\eta}_{j,i}$ operator is represented by a corresponding node with a single child.

There are many graph classes which are known to have bounded clique-width. Examples of such graph classes include every graph class of bounded treewidth [

23], co-graphs [

23], complete (bipartite) graphs and distance hereditary graphs [

24].

If the edges of

G have signs, then one can define two different variants of clique-width for

G. The

unsigned clique-width of

G is simply the clique-width of the graph

${G}^{\prime}$ obtained by removing all signs on the edges of

G. On the other hand, the

signed clique-width of

G is the minimum

k such that

G can be defined by a

signed k-expression, which is analogous to a

k-expression with the sole distinction that the operation

${\eta}_{i,j}$ is replaced by

${\eta}_{i,j}^{\ell}$ which adds an edge with sign

ℓ between all vertices labeled

i and

j. An example is provided in

Figure 1.

We list a few known facts and observations about clique-width below:

The difference between the signed clique-width (scw) and unsigned clique-width (cw) of a signed graph

G can be arbitrarily large; more precisely, for every gap

g there exists a signed graph

G such that

$\mathrm{scw}\left(G\right)\ge \mathrm{cw}\left(G\right)+g$ [

25].

There exists a function

f and a polynomial-time algorithm which takes as input a (signed) graph

G and either outputs a (signed)

$f\left(k\right)$-expression or correctly determines that the (signed) clique-width of

G is greater than

k [

26,

27].

Every signed graph of (signed) clique-width k can be defined by a (signed) k-expression which does not use the ${\eta}_{i,j}$ operator to create edges between vertices that are already adjacent (i.e., each edge is created only once).

A signed k-expression of a bipartite signed graph G with bi-partition ${V}_{1},{V}_{2}$ can be converted to a signed $(k+1)$-expression of G such that the labels used for ${V}_{1}$ are completely disjoint from those used for ${V}_{2}$ (this is because any label that was originally used for ${V}_{1}$ and ${V}_{2}$ cannot be used to create new edges).

#### 2.5. Graphical Representations

Here, we overview some natural graphical representations which have been used to capture the variable-constraint interactions of

ILP instances. We remark that such representations are not unique to the

ILP setting: indeed, they have been used and studied extensively also in settings such as, e.g., constraint programming [

28,

29] and Boolean satisfiability [

11,

30].

Let A be an $m\times n$ integer matrix that is provided as part of an ILP instance $\mathcal{I}$. The signed incidence graph of A (or, equivalently, of $\mathcal{I}$) is the edge-labeled bipartite graph ${G}_{SI}\left(\mathcal{I}\right)=(R\cup C,E,\lambda )$, where $R=\left\{{r}_{1},\dots ,{r}_{m}\right\}$ contains one vertex for each row of A and $C=\left\{{c}_{1},\dots ,{c}_{n}\right\}$ contains one vertex for each column of A. There is an edge $\{r,c\}$ with label $\lambda \left(\{r,c\}\right)={A}_{r,c}$ between the vertex $r\in R$ and $c\in C$ if ${A}_{r,c}\ne 0$, that is, if row r contains a nonzero coefficient in column c. In other words, the vertex set of ${G}_{SI}$ is $\mathrm{con}\left(\mathcal{I}\right)\cup \mathrm{var}\left(\mathcal{I}\right)$, a variable is adjacent to a constraint if and only if it occurs in that constraint with a non-zero coefficient, and the labels on edges encode this coefficient.

The

incidence graph of

A (or

$\mathcal{I}$), denoted

${G}_{I}\left(\mathcal{I}\right)$, is equal to the signed incidence graph without the edge-labels. The

primal graph of

A (or

$\mathcal{I}$) is the graph

${G}_{P}\left(\mathcal{I}\right)=(C,E)$, where

C is the set of columns of

A and

$\{c,{c}^{\prime}\}\in E$ whenever there exists a row of

A with a nonzero coefficient in both columns

c and

${c}^{\prime}$. This graph is also sometimes called the

Gaifman graph in the literature. The

dual graph of

A (or

$\mathcal{I}$) is the graph

${G}_{D}\left(\mathcal{I}\right)=(R,E)$, where

R is the set of rows of

A and

$\{r,{r}^{\prime}\}\in E$ whenever there exists a column of

A with a nonzero coefficient in both rows

r and

${r}^{\prime}$. In other words, the vertex sets of these graphs are

$\mathrm{var}\left(\mathcal{I}\right)$ and

$\mathrm{con}\left(\mathcal{I}\right)$, respectively; an edge then signifies that two variables directly interact via a constraint or that two constraints directly interact via a variable, respectively. For all graph representations introduced above, we drop the

$\mathcal{I}$ in the parenthesis when the instance is clear from context.

Figure 2 illustrates the four graphical representations of a constraint matrix.

For a decompositional width measure $\mathrm{dw}\in \{\mathrm{td},\mathrm{tw},\mathrm{cw},\mathrm{scw}\}$, we denote by ${\mathrm{dw}}_{SI}\left(\mathcal{I}\right)$, ${\mathrm{dw}}_{I}\left(\mathcal{I}\right)$, ${\mathrm{dw}}_{P}\left(\mathcal{I}\right)$, ${\mathrm{dw}}_{D}\left(\mathcal{I}\right)$, the width of the signed incidence graph, the incidence graph, the primal graph, and the dual graph of $\mathcal{I}$, respectively.

#### 2.6. Representation Stability

Changing between the equality and inequality representations for

ILP does not have a significant effect on most of the structural parameters considered in this paper. In particular, it is easy to show that the parameters td, tw, cw, scw as well as the parameters fracture number (frac) and torso-width (defined in

Section 5) differ at most by a factor of two when switching between the two representations. To see this it suffices to consider the standard transformations between

ILP${}_{=}$ and

ILP${}_{\le}$, which are given as follows.

Given an instance ${\mathcal{I}}_{=}$ of ILP${}_{=}$, we obtain an equivalent instance of ILP${}_{\le}$ by replacing every equality constraint of ${\mathcal{I}}_{=}$ with two inequality constraints and by adding the lower and upper bounds for the variables to the constraint matrix. It is easy to see that this transformation increases the above mentioned parameters for the primal, dual, and incidence graph by at most a factor of two.

Similarly, given an instance ${\mathcal{I}}_{\le}$ of ILP${}_{\le}$, we obtain an equivalent instance of ILP${}_{=}$ by introducing (i.e., adding) one novel “slack” variable to every constraint with a lower bound of 0. It is, similarly to the previous case, straightforward to show that this does not increase any of the considered parameters by more than a factor of two. As a consequence, for the statement of most of our complexity results we will simply consider instances of ILP and/or ILPF (which may be given in equality as well as in inequality form).

## 3. Solving ILPs with Explicit Restrictions

Initial work on mapping the complexity of integer linear programming predominantly focused on identifying tractable classes by placing restrictions on explicit properties of instances, such as the number of variables or of constraints. Lenstra [

8] showed that

ILP can be solved by an algorithm which has an exponential dependency on the number of variables, but only a linear dependency on the size of the instance. His running time was subsequently improved by Kannan [

9] and Frank and Tardos [

10].

**Theorem** **1** ([

8,

9,

10])

**.** An ILP instance $\mathcal{I}$ with n variables can be solved in time $\mathcal{O}({n}^{2.5n+o\left(n\right)}\xb7|\mathcal{I}\left|\right)$; in other words, ILP is fixed-parameter tractable parameterized by n.Papadimitriou showed that

ILP is fixed-parameter tractable parameterized by

$m+{\parallel A\parallel}_{\infty}+\parallel \mathbf{b}\parallel $ [

31]. His result was recently improved by Eisenbrand and Weismantel [

32], and then further improved by Jansen and Rohwedder [

33]. Even more recently, Knop, Pilipczuk and Wrochna showed that the running time of this result cannot be substantially improved [

34].

**Theorem** **2** ([

32,

33,

34])

**.** An ILP ${}_{=}$ instance $\mathcal{I}$ with m constraints can be solved in time $\mathcal{O}\left(\right(m\xb7{\parallel A\parallel}_{\infty}{)}^{m}\xb7log\parallel \mathbf{b}\parallel )$; in other words, ILP is fixed-parameter tractable parameterized by $m+{\parallel A\parallel}_{\infty}$.On the other hand, ILP remains intractable when all other obvious numerical measures are bounded. In particular, ILPF remains **NP**-complete even when ${\parallel A\parallel}_{\infty}=\parallel \mathbf{b}\parallel =\parallel \mathbf{u}\parallel =1$ and $\parallel \mathbf{l}\parallel =0$, as witnessed by the folklore encoding of the Vertex Cover problem into ILP, i.e., given a graph G and an integer k, the ILP instance has one binary variable for every vertex of G (representing of whether or not the vertex is chosen to be in a vertex cover) and for every edge between u and v a constraint ensuring that the sum of the variables for u and v is at least one (ensuring that the vertex cover contains at least one vertex from every edge).

While this is not the focus of this survey, we also mention that there is a significant body of work on exploiting algebraic properties to solve

ILP. Perhaps the most prominent example of a complexity result obtained in this vein is the well-known fact that instances

$\mathcal{I}$ whose matrix

A is

totally unimodular (i.e., each of its square submatrices has a determinant in

$\{-1,0,1\}$) can be solved in polynomial time [

35]).

**Theorem** **3** ([

35,

36])

**.** An ILP instance $\mathcal{I}$ having a totally unimodular constraint matrix can be solved in polynomial-time.We say that an ILP instance is non-negative if all entries of

A and

b are non-negative. Cunningham and Geelen [

37] showed that non-negative

ILP${}_{=}$ is fixed-parameter tractable parameterized by

$\parallel b\parallel $ and

$\omega $, where

$\omega $ is the branchwidth of the column-matroid of

A, i.e., the matroid whose elements are the column vectors of

A and whose independent sets are the set of all linearly independent column vectors.

**Theorem** **4** ([

37])

**.** A non-negative ILP ${}_{=}$ instance $\mathcal{I}$ with m constraints and n variables can be solved in time ${\mathcal{O}\left(\right(\parallel b\parallel}_{\infty}+1{)}^{2\omega}\omega mn+{m}^{2}n)$, where ω is equal to the branchwidth of the column-matroid of A.## 4. Parameters for Sparse Variable-Constraint Interactions: Treewidth and Treedepth

We note that due to the discussion at the end of

Section 2.5 all the results presented in this section hold regardless of whether our instance is provided in inequality or equality form. In 2015, Jansen and Kratsch [

36] showed that the treewidth of the primal graph can be used to efficiently solve

ILP when the variable domains are bounded by the parameter. More precisely:

**Theorem** **5** ([

36])

**.** Let c be a constant. Given an ILPF instance $\mathcal{I}$ with unary bounded domain satisfying the property that all but at most c variables have domain span at most d, and let ${G}_{P}$ be the primal graph of $\mathcal{I}$. Then $\mathcal{I}$ admits a fixed-parameter algorithm when parameterized by $d+{\mathrm{tw}}_{P}\left(\mathcal{I}\right)$.The result follows from standard leaves-to-root dynamic programming along a tree decomposition of ${G}_{P}\left(\mathcal{I}\right)$, and can be straightforwardly adapted to also solve ILP. This result provides a useful tool for dealing with instances where all variables have bounded domain. One year after Jansen and Kratsch’s result, Ganian and Ordyniak used a reduction from Subset Sum to rule out the application of treewidth In the setting of unbounded domain—even for extremely restricted instances of ILPF.

**Theorem** **6** ([

38])

**.** ILPF is **NP**-complete even when restricted to instances $\mathcal{I}$ such that ${\mathrm{tw}}_{P}\left(\mathcal{I}\right)\le 2$ and $\parallel \mathbf{b}\parallel ={\parallel A\parallel}_{\infty}=1$.In the same paper, Ganian and Ordyniak complemented this result with a fixed-parameter algorithm for

ILP parameterized by

${\mathrm{td}}_{P}\left(\mathcal{I}\right)+{\parallel A\parallel}_{\infty}+\parallel \mathbf{b}\parallel $; the proof uses a pruning technique which transforms the instance into an equivalent one of size bounded by the parameter (a “kernel”). Their result was later superseded by Koutecký, Levin and Onn [

39], who used Graver-best oracles to show:

**Theorem** **7** ([

39])

**.** ILP is **FPT** when parameterized by ${\mathrm{td}}_{P}\left(\mathcal{I}\right)+{\parallel A\parallel}_{\infty}$.We note that both parameters

${\mathrm{td}}_{P}\left(\mathcal{I}\right)$ and

${\parallel A\parallel}_{\infty}$ are required to achieve even XP algorithms: it is well known that

ILP is

**NP**-hard when restricted to instances with

${\parallel A\parallel}_{\infty}=1$, and Ganian and Ordyniak [

38] showed that it is also

**NP**-hard when restricted to instances with

${\mathrm{td}}_{P}\left(\mathcal{I}\right)\le 4$. It is worth noting that both Theorem 7 and its predecessor have a non-elementary dependency on the parameter.

In their paper, Koutecký, Levin and Onn also used the same techniques to obtain a fixed-parameter algorithm that uses the treedepth of the dual graph (as opposed to the primal one):

**Theorem** **8** ([

39])

**.** ILP is **FPT** when parameterized by ${\mathrm{td}}_{D}\left(\mathcal{I}\right)+{\parallel A\parallel}_{\infty}$.They also established an analogue to Theorem 6 for dual graphs, showing that restricting the dual or primal graphs leads to a similar complexity behavior for ILP:

**Theorem** **9** ([

39])

**.** ILPF is **NP**-complete even when restricted to instances $\mathcal{I}$ such that ${\mathrm{tw}}_{D}\left(\mathcal{I}\right)\le 3$ and with ${\parallel A\parallel}_{\infty}=2$.Since the classical encoding of Subset Sum into an instance $\mathcal{I}$ of ILPF only uses a single constraint (i.e., $\left|\mathrm{con}\right(\mathcal{I}\left)\right|=1$), it is immediate that ILPF is also **NP**-complete when ${\mathrm{td}}_{D}\left(\mathcal{I}\right)=1$; in other words, it is not possible to strengthen Theorem 8 by dropping any of the parameters. By the standard reduction from Subset Sum we mean the reduction to the ILP instance that has one binary variable for every integer in the Subset Sum instance (representing whether or not the integer is in a solution) and one constraint over all variables ensuring that the sum of all chosen integers equals the target value of the Subset Sum instance.

The third fundamental graph representation that has been considered for restricting the variable-constraint interactions of an ILP instance $\mathcal{I}$ is the incidence graph. It is worth noting that a trivial transformation of the respective decompositions yields ${\mathrm{td}}_{I}\left(\mathcal{I}\right)\le max({\mathrm{td}}_{P}\left(\mathcal{I}\right),{\mathrm{td}}_{D}\left(\mathcal{I}\right))$ and similarly ${\mathrm{tw}}_{I}\left(\mathcal{I}\right)\le max({\mathrm{tw}}_{P}\left(\mathcal{I}\right),{\mathrm{tw}}_{D}\left(\mathcal{I}\right))$; on the other hand, there are instances where both ${\mathrm{td}}_{I}\left(\mathcal{I}\right)$ and ${\mathrm{tw}}_{I}\left(\mathcal{I}\right)$ are bounded but the dual and primal graphs exhibit neither bounded treewidth nor treedepth. Hence, tractability results using the treewidth and treedepth of the incidence graph have the potential to supersede similar results for both previously considered graph representations, while any obtained hardness results carry over from primal and dual graphs to incidence graphs.

Ganian, Ordyniak and Ramanujan [

40] identified conditions under which

${\mathrm{tw}}_{I}\left(\mathcal{I}\right)$ can be used to obtain algorithms for

ILP. Notably, after factoring in Proposition 1 their result states:

**Theorem** **10.** ILPcan be solved in time ${\mathsf{\Gamma}}^{\mathcal{O}\left({\mathrm{tw}}_{I}\left(\mathcal{I}\right)\right)}\xb7\left|\mathcal{I}\right|$, where Γ is the maximum absolute value of any partial evaluation of a constraint by any feasible assignment of $\mathcal{I}$; here, a partial evaluation of a constraint/row $\mathbf{r}$ of A with a feasible assignment $\mathbf{x}$ is equal to $\mathbf{r}{\mathbf{x}}^{\prime}$, where ${\mathbf{x}}^{\prime}$ is any vector obtained from $\mathbf{x}$ after setting some of its entries to 0.

Note that $\mathsf{\Gamma}\le {n\parallel A\parallel}_{\infty}d$, where d is the maximum domain span of every variable in $\mathcal{I}$. Hence, Theorem 10, e.g., implies that fully unary ILP can be solved in polynomial-time if ${\mathrm{tw}}_{I}\left(\mathcal{I}\right)$ is bounded by a constant.

On the other hand,

ILPF remains

**NP**-complete even when restricted to instances with strong restrictions on the treewidth and coefficients—to some extent justifying the dependency of the above algorithm on

$\mathsf{\Gamma}$. Indeed, the first part of the following theorem follows from the classical encoding of

Subset Sum into

ILPF, while the second part was shown by Ganian et al. [

40].

**Theorem** **11.** ILPFremains**NP**-complete even on instances $\mathcal{I}$ with (1) ${\mathrm{tw}}_{I}\left(\mathcal{I}\right)=1$ and Boolean domains for all variables, as well as with (2) ${\mathrm{tw}}_{I}\left(\mathcal{I}\right)\le 3$ and $max(\parallel A{\parallel}_{\infty},\parallel \mathbf{b}\parallel )=2$.

A natural question is whether one can use

${\mathrm{td}}_{I}\left(\mathcal{I}\right)$ instead of

${\mathrm{tw}}_{I}\left(\mathcal{I}\right)$ in order to obtain tractability for

ILP under a weaker restriction than by bounding

$\mathsf{\Gamma}$—notably, can one lift Theorems 7 and 8 to the incidence treedepth setting? Very recently, Eiben et al. [

41] answered the question in the negative by showing:

**Theorem** **12** ([

41])

**.** ILP remains **NP**-complete even when restricted to instances $\mathcal{I}$ such that $max(\parallel A{\parallel}_{\infty},\parallel \mathbf{b}\parallel )=1$ and ${\mathrm{td}}_{I}\left(\mathcal{I}\right)\le 5$.In the full version of that paper, they also showed that restricting the structure by the size of a minimum vertex cover of ${G}_{I}\left(\mathcal{I}\right)$—a significantly stronger restriction than treedepth—leads to tractability.

**Theorem** **13.** ILPis**FPT**parameterized by ${\parallel A\parallel}_{\infty}$ and the vertex cover number of ${G}_{I}\left(\mathcal{I}\right)$.

Note that even though the vertex cover number is sensitive to changes between the equality and inequality form of ILP in general, the above theorem still holds for both forms. This is because the proof of Theorem 13 works by first observing that the number of (linearly independent) equalities is bounded by a function of the vertex cover number and ${\parallel A\parallel}_{\infty}$ and then uses Theorem 2 to show tractability. Almost the same approach can be used for inequalities, i.e., one can again observe that the number of inequalities is bounded in terms of the parameters (otherwise there are redundant inequalities) and then use the standard reduction from ILP${}_{\le}$ to ILP${}_{=}$; since the reduction does not increase the number of constraints, one can again apply Theorem 2.

We conclude this section by touching on the complexity of integer linear programs whose graph representations have an extremely simple structure—notably, have treewidth 1 (i.e., are acyclic). This setting was investigated by Eiben et al. [

42], who showed that

ILP${}_{\le}$ restricted to unary instances whose graph representations are acycllic exhibit a different complexity behavior than

ILP restricted to instances of bounded treewidth. We summarize their results in

Table 1.

## 5. Other Parameters Exploiting Variable-Constraint Interactions

Of course,

ILP has also been studied through the lens of structural parameters that are different than treewidth. The first example of such a parameter is the

fracture number of Dvořák et al. [

43], which captures the “distance” of an

ILP instance from being fractured into small independent components.

Three variants of the fracture number will be of interest for the purposes of this survey: the constraint fracture number of an ILP$\mathcal{I}$ (${\mathrm{frac}}_{C}\left(\mathcal{I}\right)$) is the minimum number ℓ of constraints that need to be deleted from $\mathcal{I}$ so that the resulting instance ${\mathcal{I}}^{\prime}$ satisfies the following: each connected component of ${G}_{I}\left({\mathcal{I}}^{\prime}\right)$ contains at most ℓ vertices. The variable fracture number (${\mathrm{frac}}_{V}\left(\mathcal{I}\right)$) and mixed fracture number ($\mathrm{frac}\left(\mathcal{I}\right)$) are then defined analogously, with the distinction that we may only delete variables or are allowed to delete both variables and constraints, respectively.

The constraint fracture number is bounded whenever the dual graph has bounded treedepth, and the mixed fracture number is bounded whenever the incidence graph has bounded treedepth (and similarily for the variables fracture number and the primal graph); however, the converse of these statements is not true. Intuitively, this means that the fracture number can be viewed as a stronger restriction than treedepth. Dvořák et al. [

43] showed that the fracture number can be used to obtain XP-algorithms for

ILP in settings which would remain

**NP**-hard if treedepth were used instead (see Theorem 12). See

Figure 3 for an illustration of the relationships between the different variants of fracture number as well as their relation to treewidth and treedepth.

**Theorem** **14** (Corollary 8, [

43])

**.** ILP admits an XP

-algorithm parameterized by ${\parallel A\parallel}_{\infty}+\mathrm{frac}\left(\mathcal{I}\right)$.**Theorem** **15** (Theorem 12, [

43])

**.** ILP restricted to unary instances admits an XP

-algorithm parameterized by ${\mathrm{frac}}_{C}\left(\mathcal{I}\right)$.Note that theorem 15 cannot be improved to an FPT-algorithm due to (Theorem 14, [

43]). Moreover, an analogous result does not hold for the mixed respectively variable fracture number as already unary

ILP is

**NP**-hard if the variable fracture number is bounded by a constant (Theorem 13, [

43]), which also excludes the use of a less restrictive parameter than constraint fracture number (such as treedepth) in Theorem 15.

Another structural parameter that can be used to solve ILP is the torso-width. The base idea behind torso-width is to decompose instances into (possibly many) separate parts with only limited interaction between them, and to solve some parts with Lenstra’s algorithm (Theorem 1) and others with dynamic programming along a tree decomposition as per Theorem 5.

To define torso-width, we will need the operation of collapsing: for a graph G and a vertex set X, the operation of collapsing X deletes X from the graph and adds an edge between each pair of neighbors of X. We denote the resulting graph $G\circ X$. Now, let q be a fixed constant. A graph G is a q-torso of $\mathcal{I}$ iff there exists a set P of variables, each with domain span at most q, such that $G={G}_{P}\left(\mathcal{I}\right)\circ P$. The q-torso-width of $\mathcal{I}$, denoted ${\mathrm{tor}}_{q}\left(\mathcal{I}\right)$, is then the minimum integer k such that $\mathcal{I}$ has a q-torso G such that:

G has treewidth at most k, and

the largest connected component of the subgraph of ${G}_{P}\left(\mathcal{I}\right)$ induced on $V\left({G}_{P}\left(\mathcal{I}\right)\right)\backslash V\left(G\right)$ contains at most k vertices.

Ganian, Ordyniak and Ramanujan [

40] showed that the

q-torso-width of

$\mathcal{I}$ can be approximated by a fixed-parameter algorithm, and that this parameter can also be used to solve

ILP. This result can be seen as a generalization of Theorem 1 as well as Theorem 5.

**Theorem** **16** (Theorem 5, [

40])

**.** For every fixed integer q, ILP is **FPT** parameterized by q-torso-width.Eiben, Ganian, Knop and Ordyniak [

42] also investigated the complexity of

ILP with respect to the parameter clique-width. They showed (and it is also not difficult to observe) that

ILPF remains

**NP**-complete even when restricted to extremely simple instances whose incidence, primal, and/or dual graphs have bounded clique-width. However,

ILP becomes polynomially tractable when restricted to unary instances of bounded signed clique-width (of their signed incidence graph), under the assumption that a suitable

k-expression is provided in the input.

**Theorem** **17.** There exists an algorithm which takes as input a unary instance $\mathcal{I}$ ofILPand a signed k-expression tree T of ${G}_{SI}\left(\mathcal{I}\right)$, runs in time $\mathcal{O}\left(\right|\mathcal{I}{|}^{4k}\xb7\left|T\right|)$, and solves $\mathcal{I}$.

## 6. Summary and Future Work

This survey provides an overview of recently obtained (as well as previously known) (in-)tractability results for

ILP with a focus on structural restrictions of the primal, dual, and incidence graph. The classes based on fracture number and treedepth can alternatively be defined in terms of block matrices and are also known as

n-fold, tree-fold, 2-stage stochastic, and multi-stage stochastic integer linear programs; a recent and comprehensive overview for these classes, their exact relation to the classes considered in this survey, as well as the current best algorithmic approaches and techniques employed for these classes is given in [

44].

Even though the complexity of

ILP w.r.t. decompositional parameters such as treedepth, treewidth, and clique-width is by now quite well understood, we believe that the study of parameterized complexity of ILP is still in its infancy. Apart from studying more restrictive settings such as tree-like instances (in combination with, e.g.,

${\parallel A\parallel}_{\infty}$) as well as related parameters such as feedback edge set, feedback vertex set, and bandwidth, we see at least two very promising directions for developing novel and even more general structural parameterizations: backdoor sets and hybrid parameters. Both of these approaches have already been successfully applied in settings such as

Boolean Satisfiability and

Constraint Satisfaction [

29,

45,

46]. Informally, a backdoor set captures the situation when an instance is “close” to being tractable, and it looks promising to develop backdoor sets into one of the newly defined tractable classes. For instance, can we solve instances of

ILP that differ from a known tractable class only by a small set of variables or constraints? Concerning the hybrid approach, where the aim is to solve instances consisting of many parts each of them tractable for a different reason, the number of possible directions seems even greater—torso-width is thus far the only explored hybrid parameter and many more tractable classes of ILP have been discovered since its introduction. Finally, it is important to explore if, how, and how far the known tractable fragments for

ILP can be employed for well-known generalizations of

ILP such as mixed or quadratic integer programs.