{'fraction_non_alphanumeric': 0.042313311464564324, 'fraction_numerical': 0.00667089340353392, 'mean_word_length': 4.244001156403585, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Solving Integer Linear Programs by Exploiting Variable-Constraint Interactions: A Survey

: Integer Linear Programming (ILP) is among the most successful and general paradigms for solving computationally intractable optimization problems in computer science. ILP is NP-complete, and until recently we have lacked a systematic study of the complexity of ILP through the lens of variable-constraint interactions. This changed drastically in recent years thanks to a series of results that together lay out a detailed complexity landscape for the problem centered around the structure of graphical representations of instances. The aim of this survey is to summarize these recent developments, put them into context and a uniﬁed format, and make them more approachable for experts from many diverse backgrounds.


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.

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

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(G) is the vertex set and E or E(G) is the edge set. A graph H is a subgraph of a graph G, denoted H ⊆ 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 , . . . , v j of G such that v = v 1 and w = v j and {v i , v i+1 } ∈ E(G) for every i with 1 ≤ 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 ∈ 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.

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 ∈ Z m×n with m rows (constraints) and n columns (variables) and vectors c, b ∈ Z m , l, u ∈ Z n ∪ {∞, −∞}. 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 ∈ Z m×n with m rows (constraints) and n columns (variables) and vectors c, b ∈ Z m . Here, the set of solutions is given by: We denote by ILPF = and ILPF ≤ 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 { y | Ay = b, l ≤ y ≤ u } is non-empty and if so to output a vector y in { y | Ay = b, l ≤ y ≤ u }. Moreover, ILP = and ILP ≤ denote the corresponding minimization versions, e.g., ILP = is the problem of deciding whether y ∈ { y | Ay = b, l ≤ y ≤ u } contains a vector y that minimizes cy and if so outputs such a vector.
For the matrix A of an instance I, we let x = (x 1 , . . . , x n ) be a vector representing the columns in A and let the variable set, denoted var(I ), be the set of such columns. If I is given in equality normal form, then its constraint set denoted by con(I ) contains one equation for every equation in the system Ax = b respectively one inequality for every inequality in the system Ax ≤ b, if 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 A ∞ , b , and c the maximum absolute value of any coefficient (entry) in the matrix A, in the vector b, and in the vector c, respectively.
For an ILP instance 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 ≤ b p and −x i ≤ b r , otherwise we say that its domain is unbounded. Moreover, we denote by x i the maximum domain span of the i-th variable, i.e., given by b p − b r if x i has bounded domain and ∞ otherwise. We denote by x ∞ the maximum domain span of any variable, i.e., max i x i . On the other hand, if I is in equality form, we say that the domain of where l i , u i are the i-th entries of l, u, respectively; otherwise, we say that the domain of x is unbounded. Moreover, we denote by x i the maximum domain span of the i-th variable, i.e., u i − l i any variable, and by x ∞ the maximum domain span of any variable, i.e., max i x i .
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, b, c, as well as l, 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.

Parameterized Complexity
In parameterized algorithmics [14][15][16][17] the runtime of an algorithm is studied with respect to a parameter k ∈ 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 (k) · n O(1) , 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 P = NP. In fact, it even allows us to rule out algorithms running in time n f (k) for any function f (these are called XP algorithms).

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 T of a graph G = (V, E) is a pair (T, χ), where T is a tree and χ is a function that assigns each tree node t a set χ(t) ⊆ V of vertices such that the following conditions hold: (T2) For every vertex v ∈ V(G), the set of tree nodes t with v ∈ χ(t) forms a non-empty subtree of T.
The sets χ(t) are called bags of the decomposition T and χ(t) is the bag associated with the tree node t. The width of a tree-decomposition (T, χ) 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 tw(G), is the width of an optimal tree decomposition of G.
Proposition 1 ([18-20]). It is possible to compute an optimal tree-decomposition of an n-vertex graph G with treewidth k in time k O(k 3 ) n, and to compute a 5-approximate one in time 2 O(k) n. Moreover, the number of nodes in the obtained tree decompositions is at most O(n).
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 F be the graph clos(F ) = (V c , E c ) with the vertex set V c = T∈F V(T) and the edge set E c = {xy : x is an ancestor of y in some T ∈ F }. A treedepth decomposition of a graph G is a rooted forest F such that G ⊆ clos(F ). The treedepth td(G) 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 On.
The following alternative (equivalent) characterization of treedepth will be useful later.

Proposition 3 ([21]). Let G i be the connected components of G. Then
We conclude with a few useful facts about treedepth.

If a graph G has no path of length d, then
for any graph G ′ 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 [k]; formally, the graph is equipped with a labeling function γ : 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(v). 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: 1. Disjoint union (denoted by ⊕); 2. Relabeling: changing all labels i to j (denoted by p i→j ); 3. Edge insertion: adding an edge between each vertex labeled by i and each vertex labeled by j, where i = j (denoted by η i,j or η j,i ).
A construction of a k-graph G using the above operations can be represented by an algebraic term composed of ⊕, p i→j and η i,j (where i = j and i, j ∈ [k]). 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(v), each ⊕ operator is represented by an ⊕ node with two children, and each p i→j and η 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 ′ 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 η i,j is replaced by η ℓ i,j 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 scw(G) ≥ cw(G) + 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 (k)-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 η 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).

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 × n integer matrix that is provided as part of an ILP instance I. The signed incidence graph of A (or, equivalently, of I) is the edge-labeled bipartite graph G SI (I) = (R ∪ C, E, λ), where R = {r 1 , . . . , r m } contains one vertex for each row of A and C = {c 1 , . . . , c n } contains one vertex for each column of A. There is an edge {r, c} with label λ({r, c}) = A r,c between the vertex r ∈ R and c ∈ C if A r,c = 0, that is, if row r contains a nonzero coefficient in column c. In other words, the vertex set of G SI is con(I ) ∪ var(I ), 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 I), denoted G I (I), is equal to the signed incidence graph without the edge-labels. The primal graph of A (or I) is the graph G P (I) = (C, E), where C is the set of columns of A and {c, c ′ } ∈ E whenever there exists a row of A with a nonzero coefficient in both columns c and c ′ . This graph is also sometimes called the Gaifman graph in the literature. The dual graph of A (or I) is the graph G D (I) = (R, E), where R is the set of rows of A and {r, r ′ } ∈ E whenever there exists a column of A with a nonzero coefficient in both rows r and r ′ . In other words, the vertex sets of these graphs are var(I ) and con(I ), 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 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 dw ∈ {td, tw, cw, scw}, we denote by dw SI (I), dw I (I), dw P (I), dw D (I), the width of the signed incidence graph, the incidence graph, the primal graph, and the dual graph of I, respectively.

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 ≤ , which are given as follows.
Given an instance I = of ILP = , we obtain an equivalent instance of ILP ≤ by replacing every equality constraint of 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 I ≤ of ILP ≤ , 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).

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-10]). An ILP instance I with n variables can be solved in time O(n 2.5n+o(n) · |I|); in other words, ILP is fixed-parameter tractable parameterized by n.
Papadimitriou showed that ILP is fixed-parameter tractable parameterized by m + A ∞ + b [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].
On the other hand, ILP remains intractable when all other obvious numerical measures are bounded. In particular, ILPF remains NP-complete even when A ∞ = b = u = 1 and l = 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 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 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 b and ω, where ω 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 I with m constraints and n variables can be solved in time
where ω is equal to the branchwidth of the column-matroid of A.

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 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 I. Then I admits a fixed-parameter algorithm when parameterized by d + tw P (I).
The result follows from standard leaves-to-root dynamic programming along a tree decomposition of G P (I), 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.
In the same paper, Ganian and Ordyniak complemented this result with a fixed-parameter algorithm for ILP parameterized by td P (I) + A ∞ + b ; 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 td P (I) + A ∞ .
We note that both parameters td P (I) and A ∞ are required to achieve even XP algorithms: it is well known that ILP is NP-hard when restricted to instances with A ∞ = 1, and Ganian and Ordyniak [38] showed that it is also NP-hard when restricted to instances with td P (I) ≤ 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 td D (I) + A ∞ .
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: ). ILPF is NP-complete even when restricted to instances I such that tw D (I) ≤ 3 and with A ∞ = 2.
Since the classical encoding of SUBSET SUM into an instance I of ILPF only uses a single constraint (i.e., | con(I )| = 1), it is immediate that ILPF is also NP-complete when td D (I) = 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 I is the incidence graph. It is worth noting that a trivial transformation of the respective decompositions yields td I (I) ≤ max(td P (I), td D (I)) and similarly tw I (I) ≤ max(tw P (I), tw D (I)); on the other hand, there are instances where both td I (I) and tw I (I) 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 tw I (I) can be used to obtain algorithms for ILP. Notably, after factoring in Proposition 1 their result states: Theorem 10. ILP can be solved in time Γ O(tw I (I)) · |I|, where Γ is the maximum absolute value of any partial evaluation of a constraint by any feasible assignment of I; here, a partial evaluation of a constraint/row r of A with a feasible assignment x is equal to rx ′ , where x ′ is any vector obtained from x after setting some of its entries to 0.
Note that Γ ≤ n A ∞ d, where d is the maximum domain span of every variable in I. Hence, Theorem 10, e.g., implies that fully unary ILP can be solved in polynomial-time if tw I (I) 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 Γ. 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]. A natural question is whether one can use td I (I) instead of tw I (I) in order to obtain tractability for ILP under a weaker restriction than by bounding Γ-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 I such that max( A ∞ , b ) = 1 and td I (I) ≤ 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 (I)-a significantly stronger restriction than treedepth-leads to tractability.

Theorem 13. ILP is FPT parameterized by A ∞ and the vertex cover number of G I (I).
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 A ∞ 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 ≤ 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 ≤ 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. Table 1. The complexity map for ILP ≤ for unary instances (first row), instances whose coefficients are encoded in unary (second row), and instances with unary bounded domain (third row). Without these restrictions, the problem becomes intractable due to the simple acyclic structure of the classical encoding of SUBSET SUM into ILP.

Acyclic Primal Graph
Acyclic Incidence Graph

ILPF ILP
UNARY P P P UNARY-C NP-hard P NP-hard UNARY-D P P NP-hard

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 I (frac C (I)) is the minimum number ℓ of constraints that need to be deleted from I so that the resulting instance I ′ satisfies the following: each connected component of G I (I ′ ) contains at most ℓ vertices. The variable fracture number (frac V (I)) and mixed fracture number (frac(I )) 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.
incidence dual Figure 3. The relationship between the structural parameters treewidth, treedepth, and fracture number for the primal, dual, and incidence graph. An arc from one parameter to another indicates that the former is a more general parameter, i.e., whenever the later is bounded so is the former. The variable, constraint, and mixed fracture number are defined in Section 5.
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 • X. Now, let q be a fixed constant. A graph G is a q-torso of I iff there exists a set P of variables, each with domain span at most q, such that G = G P (I) • P. The q-torso-width of I, denoted tor q (I), is then the minimum integer k such that 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 (I) induced on V(G P (I)) \ V(G) contains at most k vertices.
Ganian, Ordyniak and Ramanujan [40] showed that the q-torso-width of 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.
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 I of ILP and a signed k-expression tree T of G SI (I), runs in time O(|I| 4k · |T|), and solves I.

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., A ∞ ) 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.