Ondřej Čepek

Extension of O(n log n) Filtering Algorithms for the Unary Resource Constraint to Optional Activities

Scheduling is one of the most successful application areas of constraint programming mainly thanks to special global constraints designed to model resource restrictions. Among these global constraints, edge-finding and not-first/not-last are the most popular filtering algorithms for unary resources. In this paper we introduce new O(n log n) versions of these two filtering algorithms and one more O(n log n) filtering algorithm called detectable precedences. These algorithms use a special data structures Θ-tree and Θ-Λ-tree. These data structures are especially designed for “what-if” reasoning about a set of activities so we also propose to use them for handling so called optional activities, i.e. activities which may or may not appear on the resource. In particular, we propose new O(n log n) variants of filtering algorithms which are able to handle optional activities: overload checking, detectable precedences and not-first/not-last.

Nonpreemptive flowshop scheduling with machine dominance

Abstract Flowshop scheduling deals with processing a set of jobs through a set of machines, where all jobs have to pass among machines in the same order. With the exception of minimizing a makespan on two machines, almost all other flowshop problems in a general setup are known to be computationally intractable. In this paper we study special cases of flowshop defined by additional machine dominance constraints. These constraints impose certain relations among the job processing times on different machines and make the studied problems tractable.

A subclass of Horn CNFs optimally compressible in polynomial time

The problem of Horn Minimization (HM) can be stated as follows: given a Horn CNF representing a Boolean function f, find a shortest possible (optimally compressed) CNF representation of f, i.e., a CNF representation of f which consists of the minimum possible number of clauses. This problem is the formalization of the problem of knowledge compression for speeding up queries to propositional Horn expert systems, and it is known to be NP-hard. There are two subclasses of Horn functions for which HM is known to be solvable in polynomial time: acyclic and quasi-acyclic Horn functions. In this paper we define a new class of Horn functions properly containing both of the known classes and design a polynomial time HM algorithm for this new class.

Horn minimization by iterative decomposition

Given a Horn CNF representing a Boolean function f, the problem of Horn minimization consists in constructing a CNF representation off which has a minimum possible number of clauses. This problem is the formalization of the problem of knowledge compression for speeding up queries to propositional Horn expert systems, and it is known to be NP-hard. In this paper we present a linear time algorithm which takes a Horn CNF as an input, and through a series of decompositions reduces the minimization of the input CNF to the minimization problem on a“shorter” CNF. The correctness of this decomposition algorithm rests on several interesting properties of Horn functions which, as we prove here, turn out to be independent of the particular CNF representations.

Properties of SLUR formulae

Single look-ahead unit resolution (SLUR) algorithm is a nondeterministic polynomial time algorithm which for a given input formula in a conjunctive normal form (CNF) either outputs its satisfying assignment or gives up. A CNF formula belongs to the SLUR class if no sequence of nondeterministic choices causes the SLUR algorithm to give up on it. The SLUR class is reasonably large. It is known to properly contain the well studied classes of Horn CNFs, renamable Horn CNFs, extended Horn CNFs, and CC-balanced CNFs. In this paper we show that the SLUR class is considerably larger than the above mentioned classes of CNFs by proving that every Boolean function has at least one CNF representation which belongs to the SLUR class. On the other hand, we show, that given a CNF it is coNP-complete to decide whether it belongs to the SLUR class or not. Finally, we define a non-collapsing hierarchy of CNF classes SLUR(i ) in such a way that for every fixed i there is a polynomial time satisfiability algorithm for the class SLUR(i ), and that every CNF on n variables belongs to SLUR(i ) for some i ≤n .

Note: On the two-machine no-idle flowshop problem

In this short note we study a two-machine flowshop scheduling problem with the additional no-idle feasibility constraint and the total completion time criterion function. We show that one of the few papers which deal with this special problem contains incorrect claims and suggest a way how these claims can be rectified.

Nested Precedence Networks with Alternatives: Recognition, Tractability, and Models

Integrated modeling of temporal and logical constraints is important for solving real-life planning and scheduling problems. Logical constrains extend the temporal formalism by reasoning about alternative activities in plans/schedules. Temporal Networks with Alternatives (TNA) were proposed to model alternative and parallel processes, however the problem of deciding which activities can be consistently included in such networks is NP-complete. Therefore a tractable subclass of Temporal Networks with Alternatives was proposed. This paper shows formal properties of these networks where precedence constraints are assumed. Namely, an algorithm that effectively recognizes whether a given network belongs to the proposed sub-class is studied and the proof of tractability is given by proposing a constraint model where global consistency is achieved via arc consistency.

Temporal Reasoning in Nested Temporal Networks with Alternatives

Temporal networks play a crucial role in modeling temporal relations in planning and scheduling applications. Temporal Networks with Alternatives (TNAs) were proposed to model alternative and parallel processes in production scheduling, however the problem of deciding which nodes can be consistently included in such networks is NP-complete. A tractable subclass, called Nested TNAs, can still cover a wide range of real-life processes, while the problem of deciding node validity is solvable in polynomial time. In this paper, we show that adding simple temporal constraints (instead of precedence relations) to Nested TNAs makes the problem NP-hard again. We also present several complete and incomplete techniques for temporal reasoning in Nested TNAs.

On perfect 0, ± 1 matrices☆☆☆

Abstract Perfect 0,±1 matrices were introduced recently in (Conforti, Cornuejols and De Francesco, 1993) as a generalization of the well-studied class of perfect 0, 1 matrices. In this paper we provide a characterization of perfect 0,±1 matrices in terms of an associated perfect graph which one can build in O( n 2 m ) time, where m × n is the size of the matrix. We also obtain an algorithm of the same time complexity, for testing the irreducibility of the corresponding generalized set packing polytope.

Nested temporal networks with alternatives: recognition and tractability

Temporal Networks with Alternatives were proposed to model alternative and parallel processes in planning and scheduling applications. However the problem of deciding which nodes can be consistently included in such networks is NP-complete. In this paper we study a tractable subclass of Temporal Networks with Alternatives that covers a wide range of real-life processes, while the problem of deciding node validity is solvable in polynomial time. We also present an algorithm that can effectively recognize whether a given network belongs to the proposed sub-class.