Constrained read-once refutations in UTVPI constraint systems: A parallel perspective

Abstract

In this paper, we analyze two types of refutations for Unit Two Variable Per Inequality (UTVPI) constraints. A UTVPI constraint is a linear inequality of the form: $a_{i}\cdot x_{i}+a_{j} \cdot x_{j} \le b_{k}$, where $a_{i},a_{j}\in \{0,1,-1\}$ and $b_{k} \in \mathbb{Z}$. A conjunction of such constraints is called a UTVPI constraint system (UCS) and can be represented in matrix form as: ${\bf A \cdot x \le b}$. UTVPI constraints are used in many domains including operations research and program verification. We focus on two variants of read-once refutation (ROR). An ROR is a refutation in which each constraint is used at most once. A literal-once refutation (LOR), a more restrictive form of ROR, is a refutation in which each literal ($x_i$ or $-x_i$) is used at most once. First, we examine the constraint-required read-once refutation (CROR) problem and the constraint-required literal-once refutation (CLOR) problem. In both of these problems, we are given a set of constraints that must be used in the refutation. RORs and LORs are incomplete since not every system of linear constraints is guaranteed to have such a refutation. This is still true even when we restrict ourselves to UCSs. In this paper, we provide NC reductions between the CROR and CLOR problems in UCSs and the minimum weight perfect matching problem. The reductions used in this paper assume a CREW PRAM model of parallel computation. As a result, the reductions establish that, from the perspective of parallel algorithms, the CROR and CLOR problems in UCSs are equivalent to matching. In particular, if an NC algorithm exists for either of these problems, then there is an NC algorithm for matching.

1. Introduction

This paper examines several problems associated with linearly infeasible systems of Unit Two Variable Per Inequality (UTVPI) constraints. A linear relationship of the form: $a_{i}\cdot x_{i}+a_{j}\cdot x_{j} \le b_{k}$ is called a UTVPI constraint, if $a_{i},a_{j} \in \{0,1,-1\}$ and $b_{k} \in \mathbb{Z}$ . A conjunction of such constraints is called a UCS. Observe that a UCS is a specialized linear program and thus can be represented in matrix form as: ${\bf U\ :\ A \cdot x \le b}$ . This means that if U has no linear (rational) solutions, then there exists a non-negative vector y, such that ${\bf y\cdot A = 0}$ , ${\bf y\cdot b} < 0$ . This follows directly from Farkas’ Lemma (Farkas 1902). The vector y serves as a refutation of U. This is because this vector proves that U has no linear (rational) solutions. In this paper, we study a specialized form of refutation called read-once refutation. A read-once refutation (ROR) is a refutation that uses each constraint at most once. Thus, a refutation y is read-once, if each element $y_{i}$ of y belongs to the set $\{0,1\}$ . A literal-once refutation (LOR) is a refutation that uses each literal ( $x_i$ or $-x_i$ ) at most once. Note that every LOR is an ROR.

Of the various forms of linear refutation, read-once refutations can be considered to be the simplest. Observe that a read-once refutation of a system U corresponds to a subset of the constraints of U that when summed together derives a contradiction. This is in contrast to more general forms of refutation where the number of times each constraint is used is important. Additionally, since coefficients are unnecessary for read-once refutations, read-once refutations are more compact than more general forms of refutation. This makes read-once refutations a highly desirable proof of infeasibility.

Unfortunately, read-once and literal-once refutations are incomplete proof systems, since there exist infeasible linear programs that do not have such refutations. In fact, this is still the case for UCSs (see Section 2). Consequently, the problems of checking if an arbitrary UCS has a read-once or literal-once refutation are still interesting.

The primary focus of this paper is variants of the LOR and ROR problems in which we are given a set of constraints that the refutation is required to use. These variants are known as the constraint-required read-once refutation (CROR) and constraint-required literal-once refutation (CLOR) problems, respectively. We provide NC reductions between the CROR and CLOR problems in UCSs and the decision version of the minimum weight perfect matching (MWPM $_D$ ) problem (see Section 2.3). Note that the complexity class NC consists of problems solvable in polylogarithmic time by a parallel machine with polynomially many processors. In total, we will provide three NC reductions between the CROR and CLOR problems in UCSs and the MWPM $_D$ problem.

Together, these reductions prove that the CROR and CLOR problems in UCSs are NC equivalent to the MWPM $_D$ problem. All of these reductions are created assuming the CREW PRAM model of parallel computation. This extends the work done in Subramani and Wojciechowki (2019) which provided polynomial time reductions from the ROR and LOR problems in UCSs to the problem of finding a minimum weight perfect matching in an undirected graph.

The principal contributions of this paper are as follows:

1. A proof that the CROR problem in UCSs is NC equivalent to the MWPM $_D$ problem.

2. A proof that the CLOR problem in UCSs is NC equivalent to the MWPM $_D$ problem.

The rest of this paper is organized as follows: Section 2 formally describes the problems under consideration. The motivation for our work and related approaches in the literature are described in Section 3. In Section 4, we provide the NC reductions between CROR and MWPM $_D$ . In Section 5, we provide the NC reductions between CLOR and MWPM $_D$ . We conclude in Section 6 by summarizing our contributions and identifying avenues for future research.

2. Statement of Problems

In this section, we formally describe the problems under consideration and define the terms that will be used throughout this paper.

A Linear Program (LP) is a conjunction of linear inequalities. System (1) denotes the matrix representation of a linear program.

(1) \begin{eqnarray} {\bf A \cdot x \le b} \end{eqnarray}

Throughout this paper, we use n to denote the number of variables in an LP and m to denote the number of constraints. Thus, in System (1), A has dimensions $m \times n$ and ${\bf b}$ is an integral m-vector.

We now define several types of constraints referred to throughout this paper.

Definition 1. A constraint of the form $a_{i}\cdot x_{i}\le b_{k}$ is called an absolute constraint, if $a_{i} \in \{1,-1\}$ and $b_k \in \mathbb{Z}$ .

Example (1): The constraints $x_1 \le 2$ and $-x_2 \le 3$ are absolute constraints.

Definition 2. A constraint of the form $a_{i}\cdot x_{i}+a_{j}\cdot x_{j} \le b_{k}$ is called a difference constraint, if $a_{i},a_{j} \in \{1,-1\}$ , $a_{i}=-a_{j}$ , and $b_k \in \mathbb{Z}$ .

Example (2): The constraints $x_1-x_3 \le 2$ and $-x_2+x_4 \le -3$ are difference constraints.

A conjunction of difference constraints is called a difference constraint system (DCS).

Definition 3. A constraint of the form $a_{i}\cdot x_{i} +a_{j}\cdot x_{j} \le b_{k}$ is called a Unit Two Variable Per Inequality (UTVPI) constraint, if $a_{i},a_{j} \in \{0,1,-1\}$ , $a_i$ and $a_j$ are not both 0, and $b_k \in \mathbb{Z}$ .

Example (3): The constraints $x_1+x_2 \le 3$ and $-x_2-x_3 \le -4$ are UTVPI constraints.

A conjunction of UTVPI constraints is called a UTVPI constraint system (UCS).

In the above definitions, $b_{k}$ is called the defining constant of the constraint. Note that in this paper, we require $b_k$ to be integral. Additionally, the terms $x_i$ and $-x_i$ are called literals.

Note that both absolute constraints and difference constraints are UTVPI constraints.

In this paper, we examine proofs of infeasibility. In linear programs (systems of linear inequalities), we are interested in refutations that use the following inference rule:

(2) \begin{eqnarray} \dfrac{ { \sum_{i=1}^n a_i\cdot x_i} \le b_1 \phantom{conjunction} {\sum_{i=1}^n a'_i \cdot x_i} \le b_2 }{ \sum_{i=1}^n (a_i+a'_i)\cdot x_i \le b_1 + b_2 }\end{eqnarray}

Rule (2) is called the addition (ADD) rule and corresponds to the summation of constraints. The ADD rule plays a similar role in refutations of linear programs to the role played by resolution in refutations of CNF formulas. Observe that any assignment that satisfies the hypotheses of Rule (2) must also satisfy the consequent. Thus, Rule (2) is a sound inference rule.

Example (4): From the constraints $x_1 + x_2 \le 3$ and $x_3 -x_2 \le -1$ , we can derive the constraint $x_1 + x_3 \le 2$ by applying the ADD rule.

Additionally, if System (1) is unsatisfiable, then repeated applications of Rule (2) to the constraints in System (1) will result in a contradiction of the form: $0 \le -a$ , $a> 0$ . Thus, Rule (2) is a complete inference rule.

The completeness of the ADD rule was established by Farkas (1902), in a lemma that is famously known as Farkas’ Lemma for systems of linear inequalities (Schrijver 1987):

Lemma 1. Let ${\bf A \cdot x \le b}$ denote a system of m linear constraints over n variables. Then, either $\exists {\bf x}\;{\bf A \cdot x \le b}$ or (mutually exclusively), $\exists {\bf y} \in \Re_{+}^{m}\;{\bf y\cdot A =0},\;$ ${\bf y \cdot b} < 0$ .

In addition to Farkas’ Lemma, there are additional lemmata that provide pairs of linear systems such that exactly one system in the pair is feasible. Such lemmata are called “Theorems of the Alternative” (Nemhauser and Wolsey 1999).

In this paper, we refer to the y variables in Farkas’ Lemma as the Farkas’ variables. These variables provide a certificate that proves that the original system is infeasible. In general, the Farkas’ variables can assume any non-negative real value. However, we are interested only in cases where the Farkas’ variables are restricted to the set $\{0,1\}$ (see Section 2.1).

For systems of UTVPI constraints, Rule (2) can be restricted as follows:

(3) \begin{eqnarray}\dfrac{ {a_i \cdot x_i + a_j \cdot x_j \le b_{k_1}} \phantom{conj} {-a_j\cdot x_j + a_l\cdot x_l \le b_{k_2}} }{ a_i\cdot x_i + a_l\cdot x_l \le b_{k_1} + b_{k_2} }\end{eqnarray}

We refer to Rule (3) as the transitive inference rule. Although it is a restricted version of the ADD rule, it remains both sound and complete for the purposes of proving the linear infeasibility of UCSs (Lahiri and Musuvathi 2005).

2.1 The read-once refutation (ROR) problem

We now define what it means for a refutation to be read-once.

Definition 4. A refutation is said to be read-once, if each constraint is used at most once in the derivation of a contradiction.

This restriction applies to both constraints in the original system as well as those derived from previous inferences. However, a derived constraint can be reused, if it can be rederived using a different set of input constraints.

Example (5): Consider the UCS defined by System (4).

(4) \begin{eqnarray}\begin{array}{rrclcrrcl}l_{1}\,: & x_1 + x_2 & \le & -2 & & l_{2}\,: & -x_1 + x_2 & \le &0\\ l_{3}\,: & -x_2 + x_3 & \le & 0 & & l_{4}\,: & -x_2 - x_3 & \le &1\end{array}\end{eqnarray}

System (4) has the following read-once refutation:

1. 1. Apply the transitive inference rule to $l_1$ and $l_2$ to derive the constraint $l_5\;:\;2 \cdot x_2 \le -2$ .

2. 2. Apply the transitive inference rule to $l_3$ and $l_5$ to derive the constraint $l_6\;:\;x_2+x_3 \le -2$ .

3. 3. Apply the transitive inference rule to $l_4$ and $l_6$ to derive the contradiction $0 \le -1$ .

In this paper, we are interested in the problem of checking if a UCS has a read-once refutation.

Definition 5. The read-once refutation (ROR) problem: Given a UCS U, does U have a read-once refutation?

Example (6): Consider the UCS defined by System (5).

(5) \begin{eqnarray}\begin{array}{rrclcrrcl}l_{1}\,: & x_1 + x_2 & \le & -2 & & l_{2}\,: & -x_1 + x_4 & \le &1\\ l_{3}\,: & -x_1 - x_4 & \le & 1 & & l_{4}\,: & -x_2 + x_3 & \le &0 \\ l_{5}\,: & -x_2 - x_3 & \le & 0 & & & & &\end{array}\end{eqnarray}

Observe that $l_{1}$ is the only constraint in System (5) with a negative defining constant. Thus, $l_{1}$ must be included in any refutation of System (5).

Any refutation of System (5) must derive a constraint of the form $0 \le b$ where $b<0$ . Thus, all variables in $l_1$ must be eliminated by using other constraints. To eliminate $x_1$ from $l_1$ , we must include either $l_{2}$ or $l_{3}$ in the refutation. However, if only one of these constraints is included, then the variable $x_{4}$ is not eliminated. Thus, both $l_2$ and $l_3$ must be in the refutation.

Similarly, to eliminate $x_2$ from $l_1$ , we must include both $l_{4}$ and $l_{5}$ . If both constraints are not used, then the variable $x_{3}$ is not eliminated.

Thus, any refutation of System (5) must include all five constraints in the system. However, the sum of these five constraints is the constraint $l_{6}\,:\,-x_1 - x_2 \le 0$ . This is obviously not a contradiction. The only way to derive a contradiction is to include the constraint $l_{1}$ a second time. Thus, System (5) does not have a read-once refutation.

However, every infeasible UCS has a refutation in which each constraint is used at most twice (Subramani and Wojciechowski 2017).

In this paper, we study a variant of the ROR problem known as the CROR problem.

Definition 6. The constraint-required ROR (CROR) problem in UCSs: Given a UCS U and a set of constraints $S \subseteq {\bf U}$ , does U have a read-once refutation that uses all of the constraints in S?

Given an unsatisfiable UCS U, the purpose of the ROR problem is to determine if U has a read-once refutation. In other words, we wish to find a subset of constraints in U whose sum is a contradiction of the form $0 \le b$ where $b < 0$ .

As stated previously, read-once refutations can be represented by placing a restriction on the Farkas’ variables. Thus, the ROR problem can be modeled as an integer program. This integer program is represented by System 6.

(6) \begin{eqnarray} \exists {\bf y}\; {\bf y\cdot A }& = & {\bf 0} \\ \nonumber {\bf y\cdot b} & \le & -1 \\ \nonumber {\bf y} & \in & \{0,1\}^{m} \end{eqnarray}

Proposition 1. Let R be a read-once refutation of a UCS U. If we add the constraints in R, we get a contradiction of the form: $0 \le b$ , $b < 0$ .

Proof. This follows immediately from System (6).

2.2 The literal-once refutation (LOR) problem

We now define what it means for a refutation to be literal-once. First, we define a literal.

Definition 7. In a UCS, a literal is either a variable $x_i$ or its negation $-x_i$ .

Definition 8. A refutation is said to be literal-once, if each literal is used at most once in the derivation of a contradiction.

This restriction applies to both constraints in the original system as well as those derived from previous inferences. However, a derived constraint can be reused, if it can be rederived using a different set of input constraints.

Example (7): Consider the UCS defined by System (7).

(7) \begin{eqnarray}\begin{array}{rrclcrrcl}l_{1}\,: & x_1 + x_2 & \le & -2 & & l_{2}\,: & -x_1 + x_4 & \le &0\\ l_{3}\,: & -x_2 + x_3 & \le & 0 & & l_{4}\,: & -x_3 - x_4 & \le &1\end{array}\end{eqnarray}

System (7) has the following literal-once refutation:

1. 1. Apply the transitive inference rule to $l_1$ and $l_2$ to derive the constraint $l_5\;:\;x_2+x_4 \le -2$ .

2. 2. Apply the transitive inference rule to $l_3$ and $l_5$ to derive the constraint $l_6\;:\;x_3+x_4 \le -2$ .

3. 3. Apply the transitive inference rule to $l_4$ and $l_6$ to derive the contradiction $0 \le -1$ .

In this paper, we are interested in the problem of checking if a UCS has a literal-once refutation.

Definition 9. The literal-once refutation (LOR) problem: Given a UCS U, does U have a literal-once refutation?

Example (8): Recall the UCS defined by System (4).

\begin{eqnarray*}\begin{array}{rrclcrrcl}l_{1}\,: & x_1 + x_2 & \le & -2 & & l_{2}\,: & -x_1 + x_2 & \le &0\\ l_{3}\,: & -x_2 + x_3 & \le & 0 & & l_{4}\,: & -x_2 - x_3 & \le &1\end{array}\end{eqnarray*}

System (4) does not have a literal-once refutation. Observe that $l_1$ is the only constraint in System (4) with a negative right-hand side. Thus, $l_1$ must be in any refutation of System (4). Constraint $l_1$ contains the literal $x_1$ . Thus, any refutation of System (4) must use a constraint with the literal $-x_1$ . The only such constraint is $l_2$ . However, both $l_1$ and $l_2$ contain the literal $x_2$ . Thus, any refutation of System (4) that uses both $l_1$ and $l_2$ is not a literal-once refutation. However, any refutation of System (4) must contain both constraints. This means that System (4) does not have a literal-once refutation.

In this paper, we study a variant of the LOR problem known as the CLOR problem.

Definition 10. The constraint-required LOR (CLOR) problem in UCSs: Given a UCS U and a set of constraints $S \subseteq {\bf U}$ , does U have a literal-once refutation that uses all of the constraints in S?

Example (9): Consider the UCS defined by System (8).

(8) \begin{eqnarray}\begin{array}{rrclcrrcl}l_{1}\,: & x_1 + x_2 & \le & -2 & & l_{2}\,: & -x_1 - x_2 & \le &0\\ l_{3}\,: & x_1 + x_3 & \le & 1 & & l_{4}\,: & -x_1 - x_3 & \le &0\end{array}\end{eqnarray}

Let $S=\{l_1\}$ . System (8) has the following CLOR that uses all the constraints in S:

1. Apply the transitive inference rule to $l_1$ and $l_2$ to derive the contradiction $0 \le -2$ .

Now let $S=\{l_3\}$ . This constraint uses the literal $x_3$ . The only constraint in S that uses the literal $-x_3$ is $l_4$ . Thus, any refutation of System (8) that uses $l_3$ must also use $l_4$ . Observe that the constraint $l_3$ uses the literal $x_1$ and the constraint $l_4$ uses the literal $-x_1$ . This means that an LOR of System (8) that uses both $l_3$ and $l_4$ cannot use either $l_1$ or $l_2$ . However, applying the transitive inference rule to $l_3$ and $l_4$ results in the constraint $0 \le 1$ . This is not a contradiction. Thus, System (8) does not have a CLOR that uses all the constraints in S.

2.3 The minimum weight perfect matching (MWPM) problem

The problem of finding a minimum weight perfect matching (MWPM) in an undirected, weighted graph is a well-known and well-studied problem (Cook et al. 1998). Our work in this paper focuses on establishing the equivalence of the MWPM problem and the CLOR and CROR problems in UCSs. Accordingly, we provide a brief overview of the MWPM problem.

Let ${\bf G = \langle V, E, c \rangle}$ be an undirected graph, with vertex set V, edge set E, and edge cost function c. A matching is any collection of vertex-disjoint edges. A perfect matching is a matching in which each vertex $v \in {\bf V}$ is matched. Without loss of generality, we assume that $|V|$ is even, since G cannot have a perfect matching, otherwise.

In this paper, we relate the ROR problem in UCSs to the decision version of the minimum weight perfect matching (MWPM $_D$ ) problem.

Definition 11. The MWPM $_D$ problem: Given an undirected graph ${\bf G = \langle V, E, c \rangle}$ and an integer L, does G have a perfect matching with weight at most L.

Example (10): Let G be the graph in Fig. 1.

Figure 1. Undirected graph G.

1. 1. The edges , and form a matching of weight 0.

2. 2. The edges and form a perfect matching of weight 0.

3. 3. The edges and form a minimum weight perfect matching of weight $-2$ .

The MWPM $_D$ problem is one of the classical problems in combinatorial optimization (Korte and Vygen 2010). Over the years, there has been a steady stream of papers documenting improvements in algorithms for this problem (Duan et al. 2018; Edmonds 1967; Gabow 1976). While the MWPM $_D$ problem is in P, it is unknown if the MWPM $_D$ problem is in NC.

2.4 Complexity classes

We now define the complexity classes used in this paper. First, we define the complexity class NC (Papadimitriou 1994).

Definition 12. A problem belongs to the class NC, if it can be solved in polylogarithmic parallel time using a polynomial number of processors.

The class NC can be broken down further.

Definition 13. A problem belongs to the class NC $^i$ , if it can be solved in $O(\!\log^i n)$ parallel time using a polynomial number of processors.

We can also look at reductions that fall into these complexity classes.

Definition 14

1. 1. An NC reduction can be performed in polylogarithmic parallel time using a polynomial number of processors.

2. 2. An NC $^i$ reduction is one that can be performed in $O(\!\log^i n)$ parallel time using a polynomial number of processors.

Two problems which can be reduced to each other by NC reductions are known as NC equivalent.

For parallel algorithms, we have different ways to measure efficiency. These are known as work-optimality and work-efficiency (Khan et al. 2013).

Definition 15. A parallel algorithm is work-optimal, if the total work done by the algorithm is within a constant factor of the work done by the best known sequential algorithm for the same problem.

Definition 16. A parallel algorithm is work-efficient, if the total work done by the algorithm is within a logarithmic factor of the work done by the best known sequential algorithm for the same problem.

3. Motivation and Related Work

Refutations are “no”-certificates, in that they provide an explanation for why a given constraint system is infeasible. Within the realm of Boolean formulas, resolution is one of the oldest and most widely used refutation techniques (Robinson 1965). Certificates enhance the reliability of responses provided by the implementation of an algorithm. For instance, consider an algorithm for checking Boolean satisfiability. Given an instance $\phi$ of a formula in Conjunctive Normal Form (CNF), a solver typically provides a “yes/no” answer. However, the answer itself does not serve as convincing evidence that the answer provided is correct. The solver could provide a satisfying assignment in case that it decides that $\phi$ is a “yes”-instance. This assignment serves as a certificate of feasibility and can be checked independently (Blum et al. 1990). The natural question is what form a certificate of infeasibility would take. In the case of clausal formulas, resolution refutations are the preferred form of negative certificates (Vinyals et al. 2018). In general, a resolution certificate of an arbitrary 3CNF formula is exponential in the size of the formula; indeed, exponential lower bounds on the size of resolution proofs were derived in Haken (1985). This is not surprising since, if every 3CNF formula had a short resolution refutation (or a short refutation in any reasonable proof system), then it would mean that ${\bf NP=coNP}$ . Since exponential length refutations are difficult to store and actually verify, research has proceeded along the lines of finding refutations in incomplete refutation systems. One such refutation system is the read-once refutation system. Read-once refutation, when specialized to resolution, is called read-once resolution (Iwama and Miyano 1995). Another line of research is to investigate the lengths of refutations and find the shortest refutation to explain the infeasibility of the formula. In Iwama (1997), it was shown that the problem of finding the shortest resolution proofs in arbitrary 3CNF formulas is NP-complete. A stronger result was obtained in Alekhnovich et al. (1998); they showed that the problem of finding the shortest resolution proof in Horn formulas is not linearly approximable, unless P $=$ NP. This result is interesting because it is easy to see that every unsatisfiable Horn formula has a resolution refutation that is quadratic in the number of clauses.

In Iwama and Miyano (1995), it was shown that the ROR problem for resolution in arbitrary CNF formulas is NP-complete. This result was later strengthened by showing that the ROR problem for resolution in 3CNF formulas is NP-complete (Kleine Büning and Zhao 2002). In Szeider (2001), it was shown that the LOR problem for resolution in CNF formulas is NP-complete. It was later shown that the ROR problem for resolution in 2CNF formulas is NP-complete (Kleine Büning et al. 2018). In this paper, we examine these problems on continuous (as opposed to discrete) variables.

UTVPI constraints occur in a number of problem domains including but not limited to program verification (Lahiri and Musuvathi 2005), abstract interpretation (Cousot and Cousot 1977; Miné 2006), real-time scheduling (Gerber et al. 1995), and operations research (Hochbaum and (Seffi) Naor 1994). In particular, the Octagon Abstract Domain used in program verification is represented by UTVPI constraints (Harvey and Stuckey 1997; Miné 2006).

For systems of UTVPI constraints, the problem of checking for read-once refutations seems to be more difficult than that of checking for linear or even integer feasibility. Previous results have established that the problems of checking for linear feasibility and integer feasibility of a UCS can both be solved in $O(m \cdot n)$ time (Subramani and Wojciechowski 2017, 2018). However, checking for the existence of read-once refutations takes $O((m+n)^2 \cdot \log (m+n))$ time (Subramani and Wojciechowki 2019).

In Lahiri and Musuvathi (2005), the problem of checking the linear feasibility of a UCS was reduced to the problem of checking the linear feasibility of a system of difference constraints. Note that this problem is equivalent to the problem of finding shortest paths in a directed graph (Cormen et al. 2001) and thus belongs to the class NC (Leighton 1992).

In this paper, we show the equivalence of the CROR and CLOR problems in UCSs and the MWPM $_D$ problem. General matching problems have been extensively studied from the perspective of parallel complexity. However, it remains unknown if the MWPM $_D$ problem belongs to the complexity class NC (Anari and Vazirani 2020).

4. The CROR Problem in UTVPI Constraints

In this section, we show that the CROR problem in UTVPI constraints is NC equivalent to the MWPM $_D$ problem. This will be done by providing an NC reduction from the CROR problem to the MWPM $_D$ problem and an NC reduction from the MWPM $_D$ problem to the CROR problem. We will later do the same for the MWPM $_D$ problem and the CLOR problem. Fig. 2 shows these reductions.

Figure 2. NC reductions.

First, we reduce the CROR problem to the MWPM $_D$ problem. This is done using a modified version of the reduction used in Subramani and Wojciechowki (2019). For the sake of completeness, we now describe that reduction.

Given a UCS ${\bf U: A\cdot x \le b}$ , we construct the undirected graph ${\bf G} = \langle {\bf V}, {\bf E}, {\bf c} \rangle$ as follows:

1. 1. For each variable $x_i$ in U, add the vertices $x_i^+$ , ${x'_i}^+$ , $x_i^-$ , and ${x'_i}^-$ to V. Additionally, add the edges and to E.

2. 2. Add the vertices and to V. Additionally, add the edge to E.

3. 3. For each constraint $l_k$ of U, add the vertices $l_k$ and $l'_k$ to V and the edge to ${\bf E}$ . Additionally:

   1. (a) If $l_k$ is $x_i + x_j \le b_k$ , add the edges and to E.

   2. (b) If $l_k$ is $x_i - x_j \le b_k$ , add the edges and to E.

   3. (c) If $l_k$ is $-x_i + x_j \le b_k$ , add the edges and to E.

   4. (d) If $l_k$ is $-x_i - x_j \le b_k$ , add the edges and to E.

   5. (e) If $l_k$ is $x_i \le b_k$ , add the edges and to E.

   6. (f) If $l_k$ is $-x_i \le b_k$ , add the edges and to E.

Observe that if U has m constraints over n variables, then G has $(4 \cdot n + 2 \cdot m + 2)$ vertices and $(2 \cdot n +5 \cdot m + 1)$ edges. In other words, G has $O(m+n)$ vertices and $O(m+n)$ edges.

Example (11): Let us consider the UCS represented by System (9).

(9) \begin{eqnarray}\begin{array}{rrclrrcl}l_1: & x_1 - x_2 & \le & -4 & l_2: & x_1 + x_3 & \le & -4 \\ l_3: &-x_1 - x_4 & \le & -4 & l_4: & -x_1 - x_5 & \le & -4 \\ l_5: & x_2 -x_3 & \le & 0 & l_6: & x_4 + x_5 & \le & 0\end{array}\end{eqnarray}

The undirected graph corresponding to UCS (9) is shown in Fig. 3.

Figure 3. Undirected graph.

The minimum weight perfect matching in this graph is and . This matching has weight $-16$ and corresponds to the read-once refutation obtained by summing all six constraints. Note that this example is similar to Example 7 in Subramani and Wojciechowki (2019).

From Subramani and Wojciechowki (2019), G has a negative weight perfect matching, if and only if, U has a read-once refutation.

We now modify the reduction from Subramani and Wojciechowki (2019), to reduce the CROR problem in UCSs to the MWPM problem.

Let U be a UCS and let G be the corresponding undirected graph. If S is a set of constraints in U, let ${\bf G}'_S$ be the graph constructed by removing the edge from G for each constraint $l_r \in S$ .

We now relate the CROR problem in UCSs to the MWPM $_D$ problem.

Theorem 1. Let U be a UCS and let S be a set of constraints in U. U has a read-once refutation that uses all of the constraints in S, if and only if, ${\bf G}'_S$ has a negative weight perfect matching.

Proof. First, assume that U has a read-once refutation R that uses all of the constraints in S. Since R is a read-once refutation of U, the corresponding undirected graph G has a negative weight perfect matching M (Subramani and Wojciechowki 2019).

From Subramani and Wojciechowki (2019), for each constraint $l_k$ in U, the perfect matching M uses the edge , if and only if, R does not use the constraint $l_k$ . Let $l_r$ be a constraint in S. Since R uses the constraint $l_r$ , the edge is not in M. Note that this is true for each constraint in S. Thus, M is a negative weight perfect matching of the graph ${\bf G}'_S$ .

Now assume that ${\bf G}'_S$ has a negative weight perfect matching M. Note that M is also a negative weight perfect matching of G. Thus, U has a read-once refutation R (Subramani and Wojciechowki 2019).

For each constraint $l_k$ in U, the perfect matching M uses the edge if and only if, R does not use the constraint $l_k$ . Let $l_r$ be a constraint in S. Since M is a perfect matching of ${\bf G}'_S$ , M does not use the edge . Thus, R uses the constraint $l_r$ as desired.

We now show that the graph ${\bf G}'_S$ can be constructed efficiently in parallel.

Theorem 2. Given a UCS U with m constraints over n variables and a set S of constraints, the corresponding graph ${\bf G}'_S$ can be constructed in constant time using $O(m +n)$ processors.

Proof. The construction of ${\bf G}'_S$ can be performed in parallel as follows:

1. 1. For each $i=1 \ldots n$ , the $i^{\rm th}$ processor creates the vertices and edges corresponding to the variable $x_i$ . These are the vertices and edges specified in step (1) of the construction of G. All of these edges are also in ${\bf G}'_S$ . Note that, in this step, each processor creates four vertices and two edges. Additionally, no two processors are required to access the same memory locations. Thus, this step can be performed in constant time in the CREW PRAM model.

2. 2. For each $j=1 \ldots m$ , the $j^{\rm th}$ processor creates the vertices and edges corresponding to the constraint $l_j$ . These are the vertices and edges specified in step (3) of the construction of G. If $l_j \not\in S$ , then all of these edges are also in ${\bf G}'_S$ . If $l_j \in S$ , then the edge is not in ${\bf G}'_S$ . Note that, in this step, each processor creates two vertices and four or five edges. Additionally, no two processors are required to access the same memory locations. Thus, this step can be performed in constant time in the CREW PRAM model.

From this, it is easy to see that the reduction from the CROR problem in UCSs to the MWPM problem is an $\mathbf{NC}^0$ reduction.

Note that this reduction works regardless of the size of S. Thus, the CROR problem can be NC reduced to the MWPM $_D$ problem even when $|S| \in O(m)$ .

Now we need to show that this reduction can be performed in the opposite direction. That is, we want to construct an NC reduction from minimum weight perfect matching to the CROR problem in UCSs.

Let G be an undirected graph with n vertices and m edges, and let L be an arbitrary integer. From G and L, we construct a UCS U as follows.

1. 1. For each vertex $x_i$ in G, create the variable $x_i$ .

2. 2. For each edge in G, create the constraint $-x_i - x_j \le b_{k}$ .

3. 3. Let $-C$ be the smallest weight of any edge in G. If all edge weights are positive, then let $C=0$ . Additionally, let $W = \max\{m \cdot C + L +1,1\}$ .

4. 4. Create the constraint $x_1 \le (n-1) \cdot W -L-1$ .

5. 5. For each variable $x_i$ , $i=2, \ldots, n$ , create the constraint $x_i \le -W$ .

Example (12): Consider the the undirected graph G and corresponding UCS U, when $L=4$ , in Fig. 4.

Figure 4. Undirected graph and corresponding UCS.

Note that U has a read-once refutation R that uses the constraint $x_1 \le 50$ . R consists of the constraints $-x_1 -x_4 \le 1$ , $-x_2 - x_3 \le 0$ , $-x_5 - x_6 \le 2$ , $x_1 \le 50$ , and $x_2 \le -11$ through $x_6 \le-11$ . Thus, G has a perfect matching of weight at most 4. This matching consists of the edges and .

We now show that G has a perfect matching of weight at most L, if and only if, U has a read-once refutation that uses the constraint $x_1 \le (n-1) \cdot W -L-1$ .

Theorem 3. Let G be an undirected graph and let L be an arbitrary integer, G has a perfect matching of weight at most L, if and only if, the corresponding UCS U has a read-once refutation that uses the constraint $x_1 \le (n-1) \cdot W -L-1$ .

Proof. Let M be a perfect matching in G with cost $c_M \le L$ . From M, we can construct a read-once refutation R of U as follows:

1. 1. For each edge in M, add the constraint $-x_i - x_j \le b_{k}$ to R.

2. 2. Add the constraints $x_1 \le (n-1) \cdot W -L-1$ , $x_2 \le -W$ , $\ldots$ , $x_n \le -W$ to R.

Note that summing the constraints $x_1 \le (n-1) \cdot W -L-1$ , $x_2 \le-W$ , $\ldots$ , $x_n \le -W$ results in the constraint $\sum_{i=1}^n x_i\le -L-1$ .

Since M is a perfect matching, every vertex in G is used by exactly one edge in M. Thus, each variable in U is used by exactly one constraint of the form $-x_i - x_j \le b_{k}$ in R. Summing these constraints results in the constraint $-\sum_{i=1}^n x_i \le c_M$ . Summing this result with the constraint $\sum_{i=1}^n x_i \le -L-1$ results in the constraint $0 \le c_M - L-1$ . Since $c_M \le L$ , this constraint is a contradiction. Thus, R is a refutation of U. Since R uses each constraint at most once, R is a read-once refutation as desired. Additionally, note that R uses each literal at most once. Thus, R is also an LOR.

Now assume that U has a read-once refutation R that uses the constraint $x_1 \le (n-1) \cdot W -L-1$ . Any summation of the constraints in U corresponding to the edges in G results in a constraint with a defining constant H where $H \ge -C \cdot m$ since there are m such constraints and the defining constant of each constraint is at least $-C$ . If R uses f constraints of the form $x_i\le -W$ , then summing the constraints in R would result in a constraint of the form $0 \le (n-1-f) \cdot W -L-1 +H$ , where $H \ge -C \cdot m$ .

Since R is a read-once refutation, $(n-1-f) \cdot W -L-1 +H < 0$ . Note that $W \ge C \cdot M +L +1 \ge L+1-H$ . Thus, $(n-1-f) \cdot W -L-1 +H\ge (n-2-f) \cdot W$ . Since, $(n-1-f) \cdot W -L-1 +H < 0$ and $W \ge 1$ , $(n-2-f) <0$ . Thus, $f \ge n-1$ . Consequently, R must use all constraints of the form $x_i \le -W$ . Summing these constraints, together with the constraint $x_1 \le (n-1) \cdot W -L-1$ , results in the constraint $\sum_{i=1}^nx_i \le -L-1$ .

Since summing the constraints in R results in a contradiction of the form $0\le b$ where $b<0$ , the remaining constraints in R must sum together to produce a constraint of the form $-\sum_{i=1}^n x_i \le c_M$ where $c_M \le L$ . By construction of U, each $-x_i$ term must come from a constraint of the form $-x_i - x_j \le b_{k}$ . Thus, the non-absolute constraints in R have the following properties:

1. 1. Each variable $x_i$ is used by exactly one constraint in R of the form $-x_i - x_j \le b_{k}$ .

2. 2. The defining constants of these constraints sum to the value $c_M \le L$ .

Thus, the edges corresponding to these constraints form a perfect matching in G with weight at most L.

Now that we have established the correctness of the reduction from MWPM to the CROR problem in UCS, we need to show that this reduction is an NC reduction.

Theorem 4. Given an undirected graph G with n vertices and m edges, the corresponding UCS U can be constructed in $O(\!\log n)$ time using $O(m +n)$ processors.

Proof. The construction can be performed in parallel as follows:

1. 1. Find C. Note that this can be done in $O(\!\log n)$ time using O(n) processors using a divide and conquer parallel search procedure.

2. 2. For each $j=1 \ldots m$ , the $j^{\rm th}$ processor creates the constraint corresponding to the $j^{\rm th}$ edge in G. This is the constraint specified in step (2) of the construction of ${\bf U}$ . Note that no two processors are required to access the same memory locations. Thus, this step can be performed in constant time in the CREW PRAM model.

3. 3. For each $i=2 \ldots n$ , the $i^{\rm th}$ processor creates the constraint $x_i \le -W$ . Meanwhile, the first processor creates the constraint $x_1 \le (n-1) \cdot W -L-1$ . Note that, in this step, no two processors are required to access the same memory locations. Thus, this step can be performed in constant time in the CREW PRAM model.

From this, it is easy to see that the reduction from the ROR problem in UCSs to minimum weight perfect matching can be accomplished by an NC $^1$ reduction.

Note that there is only one constraint that is required to be used by the read-once refutation of U. Thus, the MWPM $_D$ problem can be NC reduced to the CROR problem in UCSs even when $|S|=1$ .

5. The CLOR Problem in UTVPI Constraints

In this section, we show that the CLOR problem in UTVPI constraints is NC equivalent to the MWPM $_D$ problem.

First, we reduce the CLOR problem to the MWPM $_D$ problem. This is done using a modified version of the reduction used in Subramani and Wojciechowki (2019). For the sake of completeness, we now describe that reduction.

Given a UCS ${\bf U: A\cdot x \le b}$ , we construct the undirected graph ${\bf G} = \langle {\bf V}, {\bf E}, {\bf c} \rangle$ as follows:

1. 1. Add the vertices $x_0^+$ and $x_0^-$ to V. Additionally, add the edge to E.

2. 2. For each variable $x_i$ in U, add the vertices $x_i^+$ and $x_i^-$ to V. Additionally, add the edge to E.

3. 3. For each constraint $l_k$ of U, add the vertices $l_k$ and $l'_k$ to V and the edge to E. Additionally:

   1. (a) If $l_k$ is of the form $x_i + x_j \le b_k$ , add the edges and to E.

   2. (b) If $l_k$ is of the form $x_i - x_j \le b_k$ , add the edges and to E.

   3. (c) If $l_k$ is of the form $-x_i + x_j \le b_k$ , add the edges and to E.

   4. (d) If $l_k$ is of the form $-x_i - x_j \le b_k$ , add the edges and to E.

   5. (e) If $l_k$ is of the form $x_i \le b_k$ , add the edges and to E.

   6. (f) If $l_k$ is of the form $-x_i \le b_k$ , add the edges and to E.

Observe that if U has m constraints over n variables, then G has $(2 \cdot n + 2 \cdot m + 2)$ vertices and $(n + 3 \cdot m + N_a + 1)$ edges where $N_a$ is the number of absolute constraints in U. Since $N_{a} \le m$ , G has $O(m+n)$ vertices and $O(m+n)$ edges.

Example (13): Let us consider the UCS represented by System (10).

(10)

The undirected graph corresponding to UCS (10) is shown in Fig. 5.

Figure 5. Undirected graph corresponding to UCS (10).

The minimum weight perfect matching in this graph is and . This matching has weight $-2$ and corresponds to the literal-once refutation obtained by summing constraints $l_1$ , $l_2$ , and $l_3$ . Note that this example is Example 5 in Subramani and Wojciechowki (2019).

From Subramani and Wojciechowki (2019), G has a negative weight perfect matching, if and only if, U has a literal-once refutation.

We now modify the reduction from Subramani and Wojciechowki (2019), to reduce the CLOR problem in UCSs to the MWPM problem.

Let U be a UCS and let G be the corresponding undirected graph. If S is a set of constraints in U, let ${\bf G}'_S$ be the graph constructed by removing the edge from G for each $l_r \in S$ .

We now relate the CLOR problem in UCSs to the MWPM $_D$ problem.

Theorem 5. Let U be a UCS and let S be a set of constraints in U. U has a literal-once refutation that uses all of the constraints in S, if and only if, ${\bf G}'_S$ has a negative weight perfect matching.

Proof. First, assume that U has a literal-once refutation R that uses all of the constraints in S. Since R is a literal-once refutation of U, the corresponding undirected graph G has a negative weight perfect matching M (Subramani and Wojciechowki 2019).

From Subramani and Wojciechowki (2019), for each constraint $l_k$ in U, the perfect matching M uses the edge , if and only if, R does not use the constraint $l_k$ . Let $l_r$ be a constraint in S. Since R uses the constraint $l_r$ , the edge is not in M. Note that this applies to every constraint in S. Thus, M is a negative weight perfect matching of the graph ${\bf G}'_S$ .

Now assume that ${\bf G}'_S$ has a negative weight perfect matching M. Note that M is also a negative weight perfect matching of G. Thus, U has a literal-once refutation R (Subramani and Wojciechowki 2019).

For each constraint $l_k$ in U, the perfect matching M uses the edge if and only if, R does not use the constraint $l_k$ . Let $l_r$ be a constraint in S. Since M is a perfect matching of ${\bf G}'_S$ , M does not use the edge . Thus, R uses the constraint $l_r$ as desired.

Theorem 6. Given a UCS U with m constraints over n variables, the corresponding graph G can be constructed in constant time using $O(m +n)$ processors.

Proof. The construction can be performed in parallel as follows:

1. 1. For each $i=1 \ldots n$ , the $i^{\rm th}$ processor creates the vertices and edges corresponding to the variable $x_i$ . These are the vertices and edges specified in step (1) of the construction of G. All of these edges are also in ${\bf G}'_S$ . Note that, in this step, each processor creates two vertices and one edge. Additionally, no two processors are required to access the same memory locations. Thus, this step can be performed in constant time in the CREW PRAM model.

2. 2. For each $j=1 \ldots m$ , the $j^{\rm th}$ processor creates the vertices and edges corresponding to the constraint $l_j$ . These are the vertices and edges specified in step (3) of the construction of G. If $l_j \not\in S$ , then all of these edges are also in ${\bf G}'_S$ . If $l_j \in S$ , then the edge is not in ${\bf G}'_S$ . Note that, in this step, each processor creates two vertices and two to four edges. Additionally, no two processors are required to access the same memory locations. Thus, this step can be performed in constant time in the CREW PRAM model.

From this, it is easy to see that the reduction from the CLOR problem in UCSs to the MWPM problem is an NC $^0$ reduction.

Now we need to show that this reduction can be performed in the opposite direction. That is, we want to construct an NC reduction from minimum weight perfect matching to the CLOR problem in UCSs.

By the proof of Theorem 3, the reduction from the MWPM $_D$ problem to the CROR problem in UCSs is also a reduction to the CLOR problem in UCSs. Thus, that reduction is an NC reduction from minimum weight perfect matching to the CLOR problem in UCSs.

6. Conclusion

In this paper, we investigated the applicability of parallelization to the problem of finding CRORs and CLORs of systems of UTVPI constraints. In previous work (Subramani and Wojciechowki 2019), the ROR and LOR problems were reduced to the minimum weight perfect matching problem. We extended these results to a more restrictive form of refutation.

Additionally, we were able to reduce minimum weight perfect matching to the CROR and CLOR problems in UTVPI constraints. This establishes these problems as being equivalent to matching from the perspective of parallel algorithms. UTVPI constraints are an important class of linear constraints that find applications in abstract interpretation and program verification. It follows that certificates of infeasibility for UTVPI constraint systems are of enormous practical significance. Read-once and literal-once certificates are particularly useful in applications, since they are “short” by definition. We are currently looking into implementing this algorithm on a parallel computer in order to empirically validate our work.

From the perspective of future research, the following avenues appear promising:

1. 1. What is the parallel complexity of the CROR problem in difference constraints? Note that difference constraints are a subset of UTVPI constraints. Thus, the CROR problem in difference constraints may be easier than the CROR problem in UTVPI constraints. This is supported by the fact that the reduction from MWPM to the CROR problem in UTVPI constraints utilizes constraints of the form $x_i + x_j \le b$ . Thus, the reduction in this paper does not work for difference constraints.

2. 2. It is known that the minimum weight perfect matching problem for planar graphs belongs to the class NC (Anari and Vazirani 2017; Sankowski 2018). Can this result be extended to provide an NC algorithm for a restricted form of UTVPI constraint systems? For example, DCSs can be modeled using directed graphs. This means that we can consider DCSs that correspond to planar graphs. It may be possible to utilize the NC matching algorithm for planar graphs to develop an NC algorithm for this class of DCSs. We can then extend this result to a similar class of UCSs.

3. 3. The problem of checking the linear feasibility of a UCS can be solved by an NC algorithm for shortest paths (Leighton 1992). Can a similar result be obtained for checking the integer feasibility of a UCS?