Search

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. [ABSTRACT FROM AUTHOR]

In this paper, we discuss exact and parameterized algorithms for the problem of finding a read-once refutation (ROR) in an unsatisfiable Horn constraint system (HCS). Recall that a linear constraint system |$\mathbf {A \cdot x \ge b}$| is said to be an HCS if each entry in |$\textbf {A}$| belongs to the set |$\{0,1,-1\}$| and at most one entry in each row of |$\textbf {A}$| is positive. In this paper, we examine the importance of constraints in which more variables have negative coefficients than positive coefficients. In particular, we study the impact of the proportion of these 'net-negative' constraints has on the difficulty of finding RORs. There exist several algorithms for checking whether an HCS is feasible. To the best of our knowledge, these algorithms are not certifying, i.e. they do not provide a certificate of infeasibility. Our work is concerned with providing a specialized class of certificates called 'read-once refutations'. In an ROR, each constraint defining the HCS may be used at most once in the derivation of a refutation. The problem of checking if an HCS has an ROR has been shown to be NP-hard. We analyse the HCS ROR problem from three different algorithmic perspectives, viz. parameterized algorithms, exact exponential algorithms and approximation algorithms. In particular, we show that the HCS ROR problem is fixed-parameter tractable (FPT) with respect to the number of constraints in the system that have more variables with negative coefficient than variables with positive coefficient. Additionally, we show that the HCS ROR problem becomes easy when this parameter is both small and large. We also derive an algorithm that runs in time |$O(1.66^{m})$|⁠ , where |$m$| is the number of constraints in the HCS. On the lower-bound side, we derive a lower bound on the algorithmic resources needed for this problem using the Exponential Time Hypothesis. We also establish that the HCS ROR problem does not have a polynomial kernel when the number of constraints with three or more variables in a refutation is used as a parameter. Finally, we show that the problem of approximating the length of the shortest ROR in an HCS is NPO PB-complete 1. [ABSTRACT FROM AUTHOR]

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 (n 3 ⋅ log k) 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 ⋅ log n) time, and returns the length of an OTLR with probability (1 − 1 e). 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). [ABSTRACT FROM AUTHOR]

In this paper, we analyze Boolean formulas in conjunctive normal form (CNF) from the perspective of read-once resolution (ROR) refutation schemes. A read-once (resolution) refutation is one in which each clause is used at most once. Derived clauses can be used as many times as they are deduced. However, clauses in the original formula can only be used as part of one derivation. It is well known that ROR is not complete; that is, there exist unsatisfiable formulas for which no ROR exists. Likewise, the problem of checking if a 3CNF formula has a read-once refutation is NP-complete. This paper is concerned with a variant of satisfiability called not-all-equal satisfiability (NAE-satisfiability). A CNF formula is NAE-satisfiable if it has a satisfying assignment in which at least one literal in each clause is set to false. It is well known that the problem of checking NAE-satisfiability is NP-complete. Clearly, the class of CNF formulas which are NAE-satisfiable is a proper subset of satisfiable CNF formulas. It follows that traditional resolution cannot always find a proof of NAE-unsatisfiability. Thus, traditional resolution is not a sound procedure for checking NAE-satisfiability. In this paper, we introduce a variant of resolution called NAE-resolution which is a sound and complete procedure for checking NAE-satisfiability in CNF formulas. The focus of this paper is on a variant of NAE-resolution called read-once NAE-resolution in which each clause (input or derived) can be part of at most one NAE-resolution step. Our principal result is that read-once NAE-resolution is a sound and complete procedure for 2CNF formulas. Furthermore, we provide an algorithm to determine the smallest such NAE-resolution in polynomial time. This is in stark contrast to the corresponding problem concerning 2CNF formulas and ROR refutations. We also show that the problem of checking whether a 3CNF formula has a read-once NAE-resolution is NP-complete. [ABSTRACT FROM AUTHOR]

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\}$$ . 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)$$ time and $$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. [ABSTRACT FROM AUTHOR]

The undirected negative cost cycle detection (UNCCD) problem is concerned with checking whether an undirected, weighted graph contains a negative cost cycle. Known approaches for solving this problem involve reducing it to either the minimum weight $$b$$ - matching problem or the minimum weight $$T$$ - join problem. In this paper, we formally describe these two approaches and provide the tightest known analysis of the $$b$$ -matching approach. Our analysis establishes that the $$b$$ -matching approach runs in $$O((n+m)^{2}\cdot \log (n+m))$$ time on a graph with $$n$$ nodes and $$m$$ edges. We also explore the case where the edge costs are integers in the range $$\{-K,\ldots , K\}$$ . For $$K = O(1)$$ , we provide improved time bounds for both the above-mentioned approaches by exploiting the existence of specialized procedures for optimization problems in graphs with integral positive edge costs. We show that while the $$T$$ -join algorithm has a better time bound for general graphs, the $$b$$ -matching algorithm is more efficient for sparse graphs. Finally, we present one of the first, extensive empirical studies for the UNCCD problem. We examine both approaches on several different families of undirected graphs. Our findings provide insight into the actual efficiency of each approach and reinforce the asymptotic analysis of our algorithms. [ABSTRACT FROM AUTHOR]

This paper proposes a new algorithm for the minimum spanning tree verification (MSTV) problem in undirected graphs. The MSTV problem is distinct from the minimum spanning tree construction problem. The above problems have been studied extensively, and there exist several papers in the literature devoted to them. Our algorithm for the MSTV problem combines the insights of Borůvka's algorithm for constructing a minimum spanning tree with a bucketing scheme. The principal idea underlying this combination is the efficient identification of edges that cannot be part of any minimum spanning tree. Although the proposed algorithm imposes no restrictions on the input graph, it was designed to exploit the case in which the number of distinct edge weights is small. On a graph with $$n$$ vertices, $$m$$ edges, and $$K$$ distinct edge weights, our algorithm runs in $$O(m+n\cdot K)$$ time. It follows that our algorithm runs in linear time if $$K$$ is a fixed constant. Although there exist several linear time MSTV algorithms in the literature, our algorithm improves on the state of the art in two ways, viz., it is conceptually simpler, and it is easy to implement. We contrast the performance of our algorithm vis-à-vis Hagerup's linear time MSTV algorithm, which is one of the more practical linear-time MSTV algorithms. Our experiments indicate that the proposed algorithm is superior to Hagerup's algorithm when $$K \le 24$$ . One surprising observation is that our algorithm is substantially faster than Hagerup's algorithm on 'No' instances, i.e., on instances in which the input spanning tree is not the minimum spanning tree. [ABSTRACT FROM AUTHOR]

In this paper, we detail a new algorithm for the problem of checking linear and integer feasibility in a system of Horn constraints. For certain special cases, the proposed algorithm is faster than the “Lifting Algorithm” for Horn constraint feasibility described in [2] . Moreover, the new approach is based on different ideas and in fact exploits several properties of Horn constraint systems (HCS) which were heretofore unknown, to the best of our knowledge. In the case of constraints of bounded width (corresponding to “loosely coupled” systems), our algorithm can be modified to run in O ( n 3 + m ⋅ n + m ⋅ n 2 log ⁡ ( max ⁡ ( m , n ) ) ) time, where n and m represent the number of variables and the number of constraints respectively, in the input HCS. Our main result establishes that checking the feasibility of an HCS can be reduced to three subproblems: negative-cost cycle detection in networks (NCCD), matrix–vector multiplication (MV), and the conversion of an HCS to a non-redundant set of difference constraints (H2D). The MV problem and the NCCD problem have both been studied extensively, as per the literature and there exist specialized, fast algorithms for the cases that are relevant to feasibility checking in Horn constraint systems. We have identified a new problem, viz., H2D, which warrants future research, since improved algorithms for the H2D problem could be implemented in our algorithm to decrease its running time even further. [ABSTRACT FROM AUTHOR]

In this paper, we discuss certifying algorithms for zero-clairvoyant scheduling (ZCS) problems. ZCS problems are a class of real-time scheduling problems defined in the E-T-C scheduling framework [Subramani, K. (2005) A comprehensive framework for specifying clairvoyance, constraints and periodicity in real-time scheduling. Comput. J., 48, 259–272]. In ZCS, the dispatcher has no knowledge of the execution time of a given job, even after the job has finished executing. A polynomial-time algorithm for ZCS was proposed in previous work of the first author [Subramani, K. (2007) A polynomial time algorithm for zero-clairvoyant scheduling. J. Appl. Logic, 5, 667–680]. However, the algorithm proposed therein is not certifying. The algorithm that we propose in this paper is certifying, in that it provides a structure that certifies the ‘yes’-instances and another structure that certifies the ‘no’-instances of ZCS problems. These structures make the discovery of implementation errors straightforward and greatly simplify the software development cycle. Moreover, the certifying algorithm has the same running time (asymptotically) as its non-certifying counterpart. We also show that the proposed certifying technique can be used to certify a class of mathematical programs called E-Quantified Polyhedral programs (E-QPPs). However, for E-QPPs, the proposed certifying algorithm has a higher asymptotic running time than its non-certifying counterpart. [ABSTRACT FROM AUTHOR]

This article is concerned with the design and analysis of polynomial time algorithms for determining whether a Planar Quantified Integer Program (PQIP) is feasible. A PQIP can be described briefly as an integer program involving two variables, in which each variable can be either universally or existentially quantified. There are four types of PQIPs, depending on how the variables are quantified (existentially or universally). In this article, we present two new, simple, and efficient algorithms for the ∀∃ case as well as a detailed account of the complexity of the other cases. Moreover, we discuss certification with respect to the provided algorithms. [ABSTRACT FROM AUTHOR]

Abstract: In this paper, we design and analyze a simple, greedy algorithm for checking the linear and integer feasibility of a class of linear programs called Horn programs. This algorithm, which we term the “Lifting Algorithm”, runs in time on a Horn system (Horn program) with constraints and variables. The Lifting Algorithm is a variant of the Stressing Algorithm which was proposed for checking the feasibility of Difference Constraint systems. Inasmuch as Horn constraints subsume difference constraints, and all known algorithms for the problem of checking feasibility of Difference Constraint Systems run in time , the running time of our algorithm is only a factor worse than the best known running time for checking the feasibility of Difference Constraint Systems. Horn programs arise in a number of application areas including econometrics and program verification; consequently, their study is well-motivated. An important feature of our algorithm is that it uses only one operator, viz., addition. We also show that our algorithm can identify the linear and lattice point feasibility of Extended Horn Systems in time. [Copyright &y& Elsevier]

Abstract: The negative cost cycle detection (NCCD) problem in weighted directed graphs is a fundamental problems in theoretical computer science with applications in a wide range of domains ranging from maximum flows to image segmentation. From the perspective of program verification, this problem is identical to the problem of checking the satisfiability of a conjunction of difference constraints. There exist a number of approaches in the literature for NCCD with each approach having its own set of advantages. Recently, a greedy, space-efficient algorithm called the stressing algorithm was proposed for this problem. In this paper, we present a novel proof of the Stressing algorithm and its verification using the Prototype Verification System (PVS) theorem prover. This example is part of a larger research program to verify the soundness and completeness of a core set of decision procedures. [Copyright &y& Elsevier]

In this paper, we propose a simple randomized algorithm for the NAE2SAT problem. The analysis of the algorithm uses the theory of symmetric, absorbing random walks. Inasmuch as the NAE2SAT problem is in the complexity class L (Deterministic Logarithmic Space) and L ⊆ P ⊆ RP, the existence of such an algorithm is not surprising. However, the simplicity of our approach and the insights revealed by its analysis make the current study worthwhile. Not-all-equal SAT (NAESAT) is the variant of the satisfiability problem (SAT), in which we are interested in an assignment that satisfies all the clauses, but falsifies at least one literal in each clause. NAESAT is an interesting SAT variant in its own right and has been studied by SAT theoreticians, on account of its connections to the graph colouring problem. It is well-known that the variant of NAESAT with exactly three literals per clause (NAE3SAT) is NP-complete [M.R. Garey and D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness, W. H. Freeman Company, San Francisco, 1979]. Likewise, there seem to be a number of polynomial time algorithms for NAE2SAT as part of algorithm design folklore [D.S. Johnson, Personal Communication]. Here we show that the NAE2SAT problem admits an extremely simple, literal-flipping algorithm, in precisely the same way that 2SAT does. On a satisfiable instance involving n variables, the probability that our algorithm does not find a satisfying assignment is at most 1/24. The randomized algorithm takes O(1) extra space, in the presence of a verifier and provides an interesting insight into checking whether a graph is bipartite. It must be noted that space-parsimonious randomized algorithms for a problem, such as the one proposed in this paper, invariably lead to error-bounded, online algorithms for the same. As part of our analysis, we argue that a restricted variant of NAE2SAT is L-complete. We note that the bounds derived in this paper are sharper than the ones in Papadimitriou [C.H. Papadimitriou, On selecting a satisfying truth assignment, in Proceedings of the 32nd Annual Symposium on Foundations of Computer Science, San Juan, Puerto Rico, 1-4 October 1991, IEEE, ed., IEEE, Washington, DC, 1991, pp. 163-169]. [ABSTRACT FROM AUTHOR]

The single source shortest paths problem with positive edge weights (SSSPP) is one of the more widely studied problems in operations research and theoretical computer science, on account of its wide applicability to practical situations. This problem was first solved in polynomial time by Dijkstra, who showed that by extracting vertices with the smallest distance from the source and relaxing its outgoing edges, the shortest path to each vertex is obtained. Variations of this general theme have led to a number of algorithms which work well in practice. At the heart of a Dijkstra implementation is the technique used to implement a priority queue. It is well known that using Dijkstra's approach requires Ω( n log n) steps on a graph having n vertices, since it essentially sorts vertices based on their distances from the source. Accordingly, the fastest implementation of Dijkstra's algorithm on a graph with n vertices and m edges should take Ω( m + n · log n) time, and consequently, the Dijkstra procedure for SSSPP using Fibonacci Heaps is optimal in the comparison-based model. In this paper, we introduce a new data structure to implement priority queues called two-level heap (TLH) and a new variant of Dijkstra's algorithm called Phased Dijkstra. We contrast the performance of Dijkstra's algorithm (both the simple and the phased variants) using a number of data structures to implement the priority queue and empirically establish that TLH are far superior to Fibonacci heaps on every graph family considered. It is to be noted that our profiling includes both sparse and dense graphs. [ABSTRACT FROM AUTHOR]

Abstract: In this paper, we propose an efficient method for implementing Dijkstra''s algorithm for the Single Source Shortest Path Problem (SSSPP) in a graph whose edges have positive length, and where there are few distinct edge lengths. The SSSPP is one of the most widely studied problems in theoretical computer science and operations research. On a graph with n vertices, m edges and K distinct edge lengths, our algorithm runs in time if , and time, otherwise. We tested our algorithm against some of the fastest algorithms for SSSPP on graphs with arbitrary but positive lengths. Our experiments on graphs with few edge lengths confirmed our theoretical results, as the proposed algorithm consistently dominated the other SSSPP algorithms, which did not exploit the special structure of having few distinct edge lengths. [Copyright &y& Elsevier]

Abstract: This paper discusses space–time tradeoffs associated with algorithms for the problem of detecting negative cost cycles in networks (NCCD). NCCD is one of the more ubiquitous problems in computer science and operations research, with applications ranging from program verification and real-time scheduling to image segmentation and shortest path identification. Typical algorithmic analysis, whether theoretical or empirical, focuses almost exclusively on the running time of the algorithm. However, there exist applications in which space is just as important a parameter as time is. This is especially true when the problem instances are very large, as is the case in program verification. Consequently, an algorithm that minimizes running time while ignoring the space overhead may be impractical. In this paper, we analyze a number of the more common algorithms for NCCD from the perspectives of both time and space, with a view towards providing a space–time tradeoff for the practitioner. All the algorithms discussed in this paper (with the exception of Network Simplex) run in time on a network with m arcs and n vertices; however, their space requirements range from (Stressing Algorithm) to (all the Bellman–Ford and Network Simplex variants). Our empirical results demonstrate that in the cases where space is paramount, the Stressing Algorithm is a useful alternative to the Bellman–Ford variants. [Copyright &y& Elsevier]

In this paper, we introduce a new randomized, partition-based algorithm for the problem of computing the number of inversion pairs in an unsorted array of n numbers. The algorithm runs in expected time O( n · log n) and uses O( n) extra space. The expected time analysis of the new algorithm is different from the analyses existing in the literature, in that it explicitly uses inversion pairs. The problem of determining the inversion pair cardinality of an array finds applications in a number of design domains, including but not limited to real-time scheduling and operations research. At the heart of our algorithm is a new inversion pair conserving partition procedure that is different from existing partition procedures such as Hoare-partition and Lomuto-partition. Although the algorithm is not fully adaptive, we believe that it is the first step towards the design of an adaptive, partition-based sorting algorithm whose running time is proportional to the number of inversion pairs in the input. [ABSTRACT FROM AUTHOR]

Abstract: In the design of real-time systems, it is often the case that certain process parameters, such as the execution time of a job are not known precisely. The challenge in real-time system design then, is to develop techniques that efficiently meet the requirements of impreciseness, while simultaneously guaranteeing safety. In a traditional scheduling model, such as the one discussed in [M. Pinedo, Scheduling: Theory, Algorithms, and Systems, Prentice-Hall, Englewood Cliffs, 1995. ]; [P. Brucker, Scheduling Algorithms, second ed., Springer, 1998. ], the tendency is to either overlook the effects of impreciseness or to simplify the issue of impreciseness by assuming worst-case values. This assumption is unrealistic and at the same time, may cause certain timing constraints to be violated at run-time. Further, depending on the nature of the constraints involved, it is not immediately apparent, what the worst-case value for a given parameter is. Whereas, in traditional scheduling, constraints among jobs are no more complex than those that can be represented by a precedence graph, in case of real-time scheduling, complicated constraints such as relative timing constraints are commonplace. Additionally, the purpose of scheduling is to achieve a schedule that optimizes some performance metric, whereas in real-time scheduling the goal is to ensure that the imposed constraints are met at run-time. In this paper, we study the problem of scheduling a set of ordered, non-preemptive jobs under non-constant execution times. Typical applications for variable execution time scheduling include process scheduling in Real-Time Operating Systems such as Maruti, compiler scheduling, database transaction scheduling and automated machine control. An important feature of application areas such as robotics is the interaction between execution times of various processes. We explicitly model this interaction through the representation of execution time vectors as points in convex sets. This modeling vastly extends previous models of execution times as either single points or range-bound intervals. Our algorithms do not assume any knowledge of the distributions of execution times, i.e. they are Zero-Clairvoyant. We present both sequential and parallel algorithms for determining the existence of a Zero-Clairvoyant schedule. To the best of our knowledge, our techniques are the first of their kind. [Copyright &y& Elsevier]

We contrast the performance of three algorithms for the problem of deciding whether a Partially Clairvoyant real-time system with relative timing constraints, as specified in the E-T-C scheduling framework, has a feasible schedule. In the E-T-C scheduling model, real-time scheduling problems are specified through a specialized class of constraint logic programs (CLPs) called Quantified Linear Programs (QLPs) [Subramani, K., 2003, An analysis of quantified linear programs. In: C.S. Calude (Ed.) Proceedings of the 4th International Conference on Discrete Mathematics and Theoretical Computer Science (DMTCS), volume 2731 of Lecture Notes in Computer Science, July (Springer-Verlag), pp. 265- 277]; thus algorithms for determining the schedulability of instances are procedures to determine the satisfiability of CLPs. Two of these algorithms, viz., the primal algorithm and the dual algorithm have already been discussed in the literature, while a third algorithm called the randomized dual algorithm has been recently proposed [Subramani, K. and Desovski, D. 2005, A new verification procedure for partially Clairvoyant scheduling. Proceedings of the 3rd International Conference on Formal Modelling and Analysis of Timed Systems (FORMATS), October; Subramani, K. and Desovski, D., 2005, Out of order quantifier elimination for standard quantified linear programs, Journal of Symbolic Computation, 40, 1383-1396]. Our experiments demonstrate that the dual-based algorithms (i.e. the dual and the randomized dual) are more effective from an implementational perspective; this is surprising since all three algorithms have the same worst case asymptotic complexity. [ABSTRACT FROM AUTHOR]

Abstract: This paper is concerned with the problem of checking whether a network with positive and negative costs on its arcs contains a negative cost cycle. The Negative Cost Cycle Detection (NCCD) problem is one of the more fundamental problems in network design and finds applications in a number of domains ranging from Network Optimization and Operations Research to Constraint Programming and System Verification. As per the literature, approaches to this problem have been either Relaxation-based or Contraction-based. We introduce a fundamentally new approach for negative cost cycle detection; our approach, which we term as the Stressing Algorithm, is based on exploiting the connections between the NCCD problem and the problem of checking whether a system of difference constraints is feasible. The Stressing Algorithm is an incremental, comparison-based procedure which is as efficient as the fastest known comparison-based algorithm for this problem. In particular, on a network with n vertices and m edges, the Stressing Algorithm takes time to detect the presence of a negative cost cycle or to report that none exists. A very important feature of the Stressing Algorithm is that it uses zero extra space; this is in marked contrast to all known algorithms that require extra space. It is well known that the NCCD problem is closely related to the Single Source Shortest Paths (SSSP) problem, i.e., the problem of determining the shortest path distances of all the vertices in a network, from a specified source; indeed most algorithms in the literature for the NCCD problem are modifications of approaches to the SSSP problem. At this juncture, it is not clear whether the Stressing Algorithm could be extended to solve the SSSP problem, even if extra space is available. [Copyright &y& Elsevier]

The article presents a study on chain programming over difference constraints. Chain programming is a restricted form of linear programming, and a chain program is characterized by a total ordering on the program variables. The study has shown that for difference constraint systems, the total ordering of the program variables results in an elegant divide and conquer algorithm for the problem of feasibility testing.

Abstract: In this paper, we present a comprehensive empirical analysis of the Vertex Contraction (VC) algorithm for the problem of checking whether a directed graph with positive and negative costs on its edges has a negative cost cycle (NCCD). VC was first presented in [K. Subramani, L. Kovalchick, Contraction versus relaxation: a comparison of two approaches for the negative cost cycle detection problem, in: P.M.A. Sloot et al. (Ed.), Proceedings of the third international conference on computational science (ICCS), Lecture notes in computer science, vol. 2659, Springer-Verlag, 2003, pp. 377–387] and is the only known purely greedy strategy for the NCCD problem. In [K. Subramani, L. Kovalchick, Contraction versus relaxation: a comparison of two approaches for the negative cost cycle detection problem, in: P.M.A. Sloot et al. (Ed.), Proceedings of the third international conference on computational science (ICCS), Lecture notes in computer science, vol. 2659, Springer-Verlag, 2003, pp. 377–387], we compared the performance profiles of a naive implementation of VC and the “standard” Bellman–Ford (BF) algorithm for negative cost cycle detection; we observed that VC performed an order of magnitude better than the BF algorithm. Our experiments were conducted on a range of randomly generated inputs over multiple classes of networks and the results conclusively demonstrated the superiority of VC over a naive implementation of BF. Our observations are surprising given that VC is asymptotically inferior to BF on sparse networks. This paper continues the study of contrasting greedy and dynamic programming (relaxation-based) approaches for the NCCD problem, by comparing sophisticated variants of VC with sophisticated implementations of the BF algorithm. Variants of VC are obtained by employing different heuristics to determine the vertex contraction sequence, in precisely the same manner as variants of BF are obtained by employing different heuristics to determine the edge relaxation sequence. Our experiments indicate that on most classes of networks, there is at least one VC variant with a performance profile that is comparable to the more sophisticated BF implementations. Our results are most surprising for the case of planar networks, where a variant of VC performs almost as well as the best relaxation-based algorithm. One of the principal conclusions of our work is that a simple, greedy approach involving vertex contraction is a good choice on sparse networks. On a more fundamental note, we establish that the selection of an algorithm for the NCCD problem should involve an analysis of the input and the architecture of the computing machine, in order to maximize performance. [Copyright &y& Elsevier]

Abstract: In this paper, we present an out of order quantifier elimination algorithm for a class of Quantified Linear Programs (QLPs) called Standard Quantified Linear Programs (SQLPs). QLPs in general and SQLPs in particular are extremely useful constraint logic programming structures that find wide applicability in the modeling of real-time schedulability specifications; see Subramani [Subramani, K., 2005a. A comprehensive framework for specifying clairvoyance, constraints and periodicity in real-time scheduling. The Computer Journal 48 (3), 259–272]. Consequently any algorithmic advance in their solution has a strong practical impact. Prior to this work, the only known approaches to the solution of QLPs involved sequential variable elimination; see Subramani [Subramani, K., 2003b. An analysis of quantified linear programs. In: Calude, C.S. et al. (Eds.), Proceedings of the 4th International Conference on Discrete Mathematics and Theoretical Computer Science. DMTCS. In: Lecture Notes in Computer Science, vol. 2731. Springer-Verlag, pp. 265–277]. In the sequential approach, the innermost quantified variable is eliminated first, followed by the variable which then becomes the innermost quantified variable and so on, until we are left with a single variable from which the satisfiability of the original formula is easily deduced. This approach is applicable in both discrete and continuous domains; however, it is to be noted that the logic demanding the sequential approach requires that the variables are discrete-valued. To the best of our knowledge, the necessity for sequential elimination over continuous-valued variables has not been investigated in the literature. The techniques used in the development of our elimination algorithm may find applications in domains such as classical logic and finite model theory. The final aspect of our research concerns the structure-preserving nature of the algorithm that we introduce here; in general, it is not known whether discrete domains admit such elimination procedures. [Copyright &y& Elsevier]

In this paper we introduce a problem called Quantified Integer Programming, which generalizes the Quantified Satisfiability problem (QSAT). In a Quantified Integer Program (QIP) the program variables can assume arbitrary integral values, as opposed to the boolean values that are assumed by the variables of an instance of QSAT. QIPs naturally represent two-person integer matrix games. The Quantified Integer Programming problem is PSPACE-hard in general, since the QSAT problem is PSPACE-complete. Quantified Integer Programming can be thought of as a restriction of Presburger Arithmetic, in that we allow only conjunctions of linear inequalities. We focus on analyzing various special cases of the general problem, with a view to discovering subclasses that are tractable. Subclasses of the general QIP problem are obtained by restricting either the constraint matrix or quantifier specification or both. We show that if the constraint matrix is totally unimodular, the problem of deciding a QIP can be solved in polynomial time. We also establish the computational complexities of Oblivious strategy games and Clairvoyant strategy games. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we empirically profile three algorithms for the Shortest Negative Cost Cycle (SNCC) problem. In this problem, we are given a directed, weighted graph G = 〈 V , E , c 〉 , and the goal is to identify a negative cost cycle with the fewest number of edges. The SNCC problem finds applications in a number of domains ranging from program verification to certifying algorithm design. The first polynomial time algorithm for this problem was proposed in Subramani (2009). Since then, several additional techniques, including a randomized approach, have been proposed for the SNCC problem. Our goal in this paper is to analyze three algorithmic paradigms for this problem from the empirical perspective. Towards this end, we profile these algorithmic approaches over a wide range of inputs. Our results indicated that the randomized algorithm is the algorithm of choice over a number of graph classes. [ABSTRACT FROM AUTHOR]