Unit Two Variable Per Inequality Constraints Research Articles

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.

On the parametrized complexity of read-once refutations in UTVPI+ constraint systems

In this paper, we study the problem of finding read-once refutations (ROR) of linear feasibility in a specialized class of constraint systems called UTVPI+ constraint systems (UCS+). The refutations in this paper are analyzed using the ADD inference rule. Recall that a Unit Two Variable Per Inequality (UTVPI) constraint is a constraint of the form ai⋅xi+aj⋅xj≤b, where b∈Z, and ai,aj∈{0,1,−1}. A conjunction of such constraints is called a UTVPI constraint system (UCS). UCSs find applications in a number of domains such as abstract interpretation and scheduling. We examine a more general form of UCSs that allows for a limited number of non-UTVPI constraints to be added to a UCS. We refer to these more general UCSs as UTVPI+ constraint systems or UCS+s. If a UCS+ has only k non-UTVPI constraints, then we refer to it as a UCSk+. Our focus in this paper is on refutations, i.e., proofs of infeasibility in UCS+s. In particular, we study read-once refutations of linear feasibility in UCS+s. Although the problem of finding read-once refutations of UCSs is polynomial time solvable, the presence of non-UTVPI constraints makes the problem NP-hard. However, if the number of non-UTVPI constraints is fixed, then read-once refutations can be found in polynomial time. In fact, in this paper, we show that the ROR problem is fixed-parameter tractable (FPT) for UCSk+s, with respect to k, the number of non-UTVPI constraints in the system. We also provide a lower bound on the efficiency of a class of parameterized algorithms for this problem, based on the Strong Exponential Time Hypothesis.

Polynomial time algorithms for optimal length tree-like refutations of linear infeasibility in UTVPI constraints

In this paper, we propose several algorithms for determining an optimal length tree-like refutation of linear feasibility in systems of Unit Two Variable Per Inequality (UTVPI) constraints. Given an infeasible UTVPI constraint system (UCS), a refutation certifies its infeasibility. The problem of finding refutations in a UCS finds applications in domains such as program verification and operations research. In general, there exist several types of refutations of feasibility in constraint systems. In this paper, we focus on a specific type of refutation called a tree-like refutation. Tree-like refutations are complete, in the sense that if a system of linear constraints is infeasible, then it must have a tree-like refutation. Associated with a refutation is its length, which equals the total number of constraints (accounting for the reuse of constraints) that are used to establish the infeasibility of the corresponding linear constraint system. Our goal in this paper is to find an optimal length tree-like refutation (OTLR) of an infeasible UCS. We describe two deterministic algorithms that find an OTLR of a UCS. If m is the number of constraints, n is the number of variables in the system, and k is the length of an OTLR, then our two algorithms run in O(n3⋅logk) time and O(m⋅n⋅k) time respectively. We also propose a true-biased, randomized algorithm for this problem. This algorithm runs in O(m⋅n⋅logn) time, and returns the length of an OTLR with probability (1−1e). We extend our work to weighted UTVPI constraint systems (WUCS), where a positive weight is associated with each UTVPI constraint. The weight of a tree-like refutation is defined as the sum of the weights of the constraints used by the refutation. The problem of finding a minimum weight refutation in a WUCS is called the weighted optimal length tree-like refutation (WOTLR) problem and is known to be NP-hard. We propose a pseudo-polynomial time algorithm for the WOTLR problem and convert it into a fully polynomial time approximation scheme (FPTAS).

On integer closure in a system of unit two variable per inequality constraints

In this paper, we study the problem of computing the lattice point closure of a conjunction of Unit Two Variable Per Inequality (UTVPI) constraints. We accomplish this by adapting Johnson’s all pairs shortest path algorithm to UTVPI constraint systems (UCSs). Thus, we obtain a closure algorithm that is efficient for sparse constraint systems. This problem has been extremely well-studied in the literature, since it arises in a number of applications, including but not limited to, program verification and operations research. In UTVPI constraints, linear feasibility does not always imply integer feasibility. Thus, there is a difference between the linear closure of a UCS and the integer closure of that same system. Finding the linear closure requires only a single inference rule called the transitive inference rule. This inference rule corresponds to the addition of constraints and preserves both linear and integer solutions. The problem of finding the integer closure requires the use of the tightening inference rule. Unlike the transitive inference rule, the tightening inference rule does not preserve linear solutions. However, it does preserve integer solutions. The complexity of solving the integer closure problem has steadily improved over the past several decades with the fastest algorithm for this problem running in time O(n3) on a UCS with n variables and m constraints. For the same input parameters, we detail an algorithm that runs in time $O(m\cdot n +n^{2} \cdot \log n)$ . It is clear that our algorithm is superior to the state of the art when the UCS is sparse (m ∈ o(n2)), and no worse than the state of the art when the UCS is dense (m ∈Θ(n2)). The best known running time for computing the closure of a conjunction of difference constraints (m constraints, n variables) is $O(m\cdot n +n^{2} \cdot \log n)$ , and UTVPI constraints subsume difference constraints.

A Polynomial Time Algorithm for Read-Once Certification of Linear Infeasibility in UTVPI Constraints

In this paper, we discuss the design and analysis of polynomial time algorithms for two problems associated with a linearly infeasible system of Unit Two Variable Per Inequality (UTVPI) constraints, viz., (a) the read-once refutation (ROR) problem, and (b) the literal-once refutation (LOR) problem. Recall that a UTVPI constraint is a linear relationship 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\}\). A conjunction of such constraints is called a UTVPI constraint system (UCS) and can be represented in matrix form as: \(\mathbf{A \cdot x \le b}\). These constraints find applications in a host of domains including but not limited to operations research and program verification. For the linear system \(\mathbf{A\cdot x \le b}\), a refutation is a collection of m variables \(\mathbf{y}=[y_{1},y_{2},\ldots , y_{m}]^{T} \in \mathfrak {R}^{m}_{+}\), such that \(\mathbf{y\cdot A =0}\), \(\mathbf{y \cdot b } < 0\). Such a refutation is guaranteed to exist for any infeasible linear program, as per Farkas’ lemma. The refutation is said to be read-once, if each \(y_{i} \in \{0,1\}\). Read-once refutations are incomplete in that their existence is not guaranteed for infeasible linear programs, in general. Indeed they are not complete, even for UCSs. Hence, the question of whether an arbitrary UCS has an ROR is both interesting and non-trivial. In this paper, we reduce this problem to the problem of computing a minimum weight perfect matching (MWPM) in an undirected graph. This transformation results in an algorithm that runs in in time polynomial in the size of the input UCS. Additionally, we design a polynomial time algorithm (also via a reduction to the MWPM problem) for a variant of read-once resolution called literal-once resolution. The advantage of reducing our problems to the MWPM problem is that we can leverage recent advances in algorithm design for the MWPM problem towards solving the ROR and LOR problems in UCSs. Finally, we show that another variant of read-once refutation problem called the non-literal read-once refutation (NLROR) problem is NP-complete in UCSs.

A certifying algorithm for lattice point feasibility in a system of UTVPI constraints

This paper is concerned with the design and analysis of a certifying algorithm for checking the lattice point feasibility of a class of constraints called unit two variable per inequality (UTVPI) constraints. A UTVPI constraint has at most two non-zero variables and the coefficients of the non-zero variables belong to the set $$\{+\,1,\ -\,1\}$${+1,-1}. These constraints occur in a number of application domains, including but not limited to program verification, abstract interpretation, and operations research. As per the literature, the fastest known model generating algorithm for checking lattice point feasibility in UTVPI constraint systems runs in $$O(m \cdot n+n^{2} \cdot \log n)$$O(m·n+n2·logn) time and $$O(n^{2})$$O(n2) space, where m represents the number of constraints and n represents the number of variables in the constraint system (Lahiri and Musuvathi, in: Proceedings of the 5th international workshop on the frontiers of combining systems (FroCos), lecture notes in computer science, vol 3717, pp 168---183, 2005). In this paper, we design and analyze a new algorithm for checking the lattice point feasibility of UTVPI constraints. The presented algorithm runs in $$O(m \cdot n)$$O(m·n) time and $$O(m+n)$$O(m+n) space. Additionally it is certifying in that it produces a satisfying assignment in the event that it is presented with feasible instances and refutations in the event that it is presented with infeasible instances. The importance of providing certificates cannot be overemphasized, especially in mission-critical applications. Our approaches for the lattice point feasibility problem in UTVPI constraint systems is fundamentally different from existing approaches for this problem; indeed, it is based on new insights into combining well-known inference rules for these systems.

A Combinatorial Certifying Algorithm for Linear Feasibility in UTVPI Constraints

In this paper, we discuss a new combinatorial certifying algorithm for the problem of checking linear feasibility in Unit Two Variable Per Inequality (UTVPI) constraints. A UTVPI constraint has at most two non-zero variables and the coefficients of the non-zero variables belong to the set $$\{+1,\ -1\}$${+1,-1}. These constraints occur in a number of application domains, including but not limited to program verification, abstract interpretation, and operations research. The proposed algorithm runs in $$O(m\cdot n)$$O(m·n) time and $$O(m+n)$$O(m+n) space on a UTVPI system with n variables and m constraints. Observe that these resource bounds match the bounds of the fastest strongly polynomial algorithm for difference constraints. Inasmuch as UTVPI constraints subsume difference constraints, it is clear that the resource requirements of our algorithm are optimal. Additionally, our algorithm is certifying, in that it produces a satisfying assignment when presented with a feasible instance, and a refutation, otherwise. At the heart of our algorithm is a new constraint network representation for UTVPI constraints.

Incremental Satisfiability and Implication for UTVPI Constraints

Unit two-variable-per-inequality (UTVPI) constraints form one of the largest class of integer constraints that are polynomial time solvable (unless P = NP). There is considerable interest in their use for constraint solving, abstract interpretation, spatial database algorithms, and theorem proving. In this paper we develop new incremental algorithms for UTVPI constraint satisfaction and implication checking that require ℴ(m + n log n + p) time and ℴ(n + m + p) space to incrementally check satisfiability of m UTVPI constraints on n variables, and we check the implication of p UTVPI constraints. The algorithms can be straightforwardly extended to create nonincremental implication checking and generation of all (nonredundant) implied constraints, as well as generate minimal unsatisfiable subsets and minimal implicants.

On Solving Boolean Combinations of UTVPI Constraints

We consider the satisabilit y problem for Boolean combinations of unit two variable per inequality (UTVPI) constraints. A UTVPI constraint is linear constraint containing at most two variables with non-zero coecien ts, where furthermore those coecien ts must be either 1 or 1. We prove that if a satisfying solution exists, then there is a solution with each variable taking values in [ n (bmax + 1); n (bmax + 1)], where n is the number of variables, and bmax is the maximum over the absolute values of constants appearing in the constraints. This solution bound improves over previously obtained bounds by an exponential factor. Our result can be used in a nite instantiation-based approach to deciding satisabilit y of UTVPI formulas. An experimental evaluation demonstrates the eciency of such an approach. One of our key results is to show that an integer point inside a UTVPI polyhedron, if one exists, can be obtained by rounding a vertex. As a corollary of this result, we also obtain a polynomial-time algorithm for approximating optima of UTVPI integer programs to within an additive factor.