Integer Feasibility and Refutations in UTVPI Constraints Using Bit-Scaling

Abstract

This paper is concerned with the design and analysis of a bit-scaling based algorithm for the problem of checking integer feasibility in a system of unit two variable per inequality (UTVPI) constraints (IF). The insights developed during algorithm design result in new techniques for extracting refutations of integer feasibility in such systems. Recall that a UTVPI constraint is a linear constraint of the form: $a_i\cdot x_i+a_j \cdot x_j \le b_{ij}$, where $a_i, a_j \in \{0,1,-1\}$ and $b_{ij} \in {\mathbb {Z}}$. These constraints arise in a number of application domains including but not limited to program verification (array bounds checking and abstract interpretation), operations research (packing and covering), and logic programming. Over the years, several algorithms have been proposed for the IF problem. Most of these algorithms are based on two inference rules, viz. the transitive rule and the tightening rule. None of these algorithms are bit-scaling. In other words, the running times of these algorithms are parameterized only by the number of variables and the number of constraints in the UTVPI constraint system (UCS) and not by the sizes of input constants. We introduce a novel algorithm for the IF problem, which is based on a collection of new insights. These insights are used to design a new bit-scaling algorithm for IF that runs in $O(\sqrt{n}\cdot m \cdot \log _2 C)$ time, where n denotes the number of variables, m denotes the number of constraints, and C denotes the absolute value of the most negative constant defining the UCS. An interesting consequence of our research is the development of techniques for extracting refutations of integer infeasibility in UCSs that are linearly feasible. If the UCS is linearly feasible, then our algorithm creates a 2CNF formula. The UCS has an integer refutation (i.e., does not have a lattice point) if and only if the created 2CNF formula has a resolution refutation (i.e., is unsatisfiable).

A Goldberg’s Algorithm

We now provide detailed description of Goldberg’s Algorithm (Goldberg()). Let $\mathbf{G}$ be a directed graph and let $-C$ be the smallest weight of any edge in $\mathbf{G}$.

Initially, $\epsilon = 2^{1+\lfloor \log _2 C\rfloor }$. This ensures that $C<\epsilon$. Let $\mathbf{p}$ be the price function for the vertices in $\mathbf{G}$. Initially, $\mathbf{p}$ is uniformly 0. For price function $\mathbf{p}$, we define the reduced cost $l_\mathbf{p}$ of an edge $e = (x_i,x_j)$ as $l_\mathbf{p}(e) =$ weight $(e) + p_i - p_j$. Note that $\mathbf{p}$ is $\epsilon$-feasible if $l_\mathbf{p}(e) > \epsilon$ for every edge in $\mathbf{G}$.

Based on the value of $l_\mathbf{p}$, the edge e can be classified as admissible or as improvable. The edge e is admissible if $l_\mathbf{p}(e) \le 0$ and is improvable if $l_\mathbf{p}(e) \le \frac{\epsilon }{2}$. A node $x_i$ is improvable if it has an inbound improvable edge. Note that if $\mathbf{G}$ has no improvable edges, then $\mathbf{p}$ is $\frac{\epsilon }{2}$-feasible. The subgraph of $\mathbf{G}$ consisting of the admissible edges is called the Admissible Graph $\mathbf{G_p}$.

Goldberg() then calls Refine() to convert $\mathbf{p}$ from an $\epsilon$-feasible (Definition 7) price function into an $\frac{\epsilon }{2}$-feasible price function. This is done until either:

• 1. It reaches a value of $\epsilon$ for which no $\epsilon$-feasible solution is found. In this case, $\mathbf{G}$ has a negative cycle c. Goldberg() then returns this negative cycle.

• 2. $\mathbf{p}$ is a 1-feasible price function. In this case, $\mathbf{p}$ is a feasible price function.

First, Refine() computes the Admissible Graph $\mathbf{G_p}$. Then it computes the strongly-connected components (SCCs) of $\mathbf{G_p}$. If any SCC of $\mathbf{G_p}$ contains an edge $e_{ij}$ from $x_i$ to $x_j$ with negative reduced cost, then $\mathbf{G}$ has a negative cycle c. Note that c consists of the edge $e_{ij}$ and the path from $x_j$ to $x_i$ in the SCC. Thus, once the edge $e_{ij}$ is found, the cycle c can be constructed in O(m) time. Otherwise, each SCC of $\mathbf{G_p}$ is contracted to a single vertex. This process is known as decycling and the resultant graph is called the Decycled Admissible Graph.

Refine() then utilizes processes known as Cut-Relabel (Cut-Relabel()) and Eliminate Chain (Eliminate-Chain()) to transform $\mathbf{p}$ from an $\epsilon$-feasible price function into an $\frac{\epsilon }{2}$-feasible price function.

Cut-Relabel() operates on a set S of vertices such that no edges in $\mathbf{G_p}$ leave S. Such a set S is called closed. Cut-Relabel() decreases the price function $p_i$ by $\frac{\epsilon }{2}$ for every vertex $x_i \in S$. This has the following results:

• 1. Every improvable edge entering S is no longer improvable.

• 2. Every improvable vertex $x_i \in S$ such that every improvable edge into $x_i$ enters S is no longer improvable.

• 3. No additional edges are made improvable.

Thus, with a properly chosen set S, Cut-Relabel(), reduces the total number of improvable vertices.

Eliminate-Chain() operates on a path r containing improvable edges. Let $e_j$ be the $j^{th}$ improvable edge from the end of r. Additionally, let $S_j$ be the set of vertices reachable from the destination vertex of $e_j$. Eliminate-Chain() then calls Cut-Relabel() on each set $S_j$. This has the following results:

• 1. The destination vertex of every improvable edge in r is no longer improvable.

• 2. No additional edges are made improvable.

Note that for each j, $S_j \subseteq S_{j+1}$. Thus, Eliminate-Chain() can be executed in O(m) time.

If $\mathbf{G_p}$ contains k improvable vertices, then there exists a set S or a path r such that running Cut-Relabel() on S or Eliminate-Chain() on r reduces the number of improvable vertices in $\mathbf{G_p}$ by $\sqrt{k}$. Additionally such a set or path can be found in O(m) time. Thus, Refine() can convert an $\epsilon$-feasible price function into an $\frac{\epsilon }{2}$-feasible price function with $O(\sqrt{n})$ calls to either Cut-Relabel() or Eliminate-Chain().

This means that each call to Refine() takes at most $O(\sqrt{n} \cdot m)$ time and $\mathbf{p}$ is refined at most $\log _2 C$ times. Thus, the algorithm has an overall running time of $O(\sqrt{n} \cdot m \cdot \log _2 C)$.

1.1 A.1 Worked Example

Let $\mathbf{G}$ be the directed graph in Fig. 5. We show what happens when Goldberg() is run on $\mathbf{G}$.

Fig. 5

Directed graph

Since the most negative edge weight in $\mathbf{G}$ is $-1$, we start with $\epsilon = 2^{1+\log _2 1} =2$. Our initial 2-feasible price function $\mathbf{p}$ assigns a value of 0 to every vertex. This is shown in Table 2.

Table 2 Initial price function $\mathbf{p}$

Every edge in $\mathbf{G}$ is currently admissible (has non-positive reduced cost). Thus, the Graph in Fig. 5 is also the Admissible Graph $\mathbf{G_p}$. The Admissible Graph $\mathbf{G_p}$ has only one SCC with multiple vertices ($x_6$, $x_7$, and $x_8$). Thus, decycling $\mathbf{G_p}$ combines these vertices into a single vertex. Let $x_\alpha$ denote this vertex. The Decycled Admissible Graph is shown in Fig. 6.

Fig. 6

Decycled Admissible Graph

Now that $\mathbf{G_p}$ has been decycled, we can refine the 2-feasible price function $\mathbf{p}$ into a 1-feasible price function. Recall that this is done by calling Cut-Relabel() and Eliminate-Chain() until no improvable vertices remain.

$\mathbf{G_p}$ currently has 5 improvable vertices ($x_2$, $x_3$, $x_4$, $x_5$, and $x_\alpha$). The path $x_1 \overset{-1}{\rightarrow } x_2 \overset{-1}{\rightarrow } x_3 \overset{-1}{\rightarrow } x_4$ contains $3 > \sqrt{5}$ improvable vertices. Thus, we run Eliminate-Chain() on this path. This involves running Cut-Relabel() on set $S_1$ (the set of vertices reachable from $x_4$), set $S_2$ (the set of vertices reachable from $x_3$), and set $S_3$ (the set of vertices reachable from $x_2$). These sets are shown in Fig. 7.

Fig. 7

Sets $S_i$ for Eliminate-Chain()

Recall that the vertex sets made by Eliminate-Chain() are nested. Thus, the price of vertices in $S_1$ (the vertex $x_4$) is decreased by $3 \cdot 1=3$, the price of vertices in $S_2 \setminus S_1$ (the vertices $x_3$ and $x_\alpha$) is decreased by $2 \cdot 1 =2$, and the price of vertices in $S_3 \setminus S_2$ (the vertices $x_2$ and $x_5$) is decreased by $1 \cdot 1 =1$. This results in the price function shown in Table 3.

Table 3 Price function $\mathbf{p}$ after Eliminate Chain()

The change in price function changes the Admissible Graph $\mathbf{G_p}$. Note that the edge from $x_5$ to $x_\alpha$ now has reduced cost $0 + (-1) - (-2) =1$. Thus, this edge is no longer admissible. This new graph is shown in Fig. 8.

Fig. 8

Decycled Admissible Graph after Eliminate-Chain()

$\mathbf{G_p}$ currently has 2 improvable vertices ($x_5$ and $x_\alpha$). The set $S = \{x_5,x_\alpha \}$ is closed since no admissible edges leave S. S also contains 2 vertices such that all improvable edges into those vertices enter S. Thus, running Cut-Relabel() on S will reduce the number of improvable vertices by $2 > \sqrt{2}$. The set S is shown in Fig. 9.

Fig. 9

Set S for Cut-Relabel()

Calling Cut-Relabel() on the set S will reduce the price of the vertices in S ($x_5$ and $x_\alpha$) by 1. This results in the price function shown in Table 4.

Table 4 Price function $\mathbf{p}$ after Cut-Relabel()

The change in price function changes the Admissible Graph $\mathbf{G_p}$. Note that the edge from $x_1$ to $x_5$ now has reduced cost $-1 + 0 - (-2) =1$. Thus, this edge is no longer admissible. This new graph is shown in Fig. 10.

Fig. 10

Decycled Admissible Graph after Cut-Relabel()

$\mathbf{G_p}$ no longer has any admissible vertices. Thus, the price function $\mathbf{p}$ is 1-feasible. Recall that this means that $\mathbf{p}$ is a feasible price function. Thus, the current price function $\mathbf{p}$ is returned by Goldberg().