Solving the Resource Constrained Project Scheduling Problem with Generalized Precedences by Lazy Clause Generation

The technical report presents a generic exact solution approach for minimizing the project duration of the resource-constrained project scheduling problem with generalized precedences (Rcpsp/max). The approach uses lazy clause generation, i.e., a hybrid of finite domain and Boolean satisfiability solving, in order to apply nogood learning and conflict-driven search on the solution generation. Our experiments show the benefit of lazy clause generation for finding an optimal solutions and proving its optimality in comparison to other state-of-the-art exact and non-exact methods. The method is highly robust: it matched or bettered the best known results on all of the 2340 instances we examined except 3, according to the currently available data on the PSPLib. Of the 631 open instances in this set it closed 573 and improved the bounds of 51 of the remaining 58 instances.

💡 Research Summary

The paper tackles the Resource‑Constrained Project Scheduling Problem with generalized precedences (RCPSP/max), a notoriously hard combinatorial optimisation problem that combines minimum/maximum time‑lag constraints between activities with multi‑resource capacity limits. While many exact approaches—pure constraint programming (CP), mixed‑integer programming (MIP), and hybrid CP‑MIP models—have been proposed, they often struggle to prove optimality on large benchmark sets, and meta‑heuristics, although scalable, cannot guarantee optimal solutions.

The authors introduce a generic exact solution framework based on Lazy Clause Generation (LCG), a hybrid of finite‑domain CP and Boolean SAT solving. In the LCG model, each activity’s start time is represented as an integer variable. Resource capacities are encoded as global cardinality constraints, and generalized precedences are expressed as difference constraints (i.e., start_j – start_i ≥ l_ij and ≤ u_ij). During search, standard CP propagation (domain reduction, bounds consistency, global resource reasoning) is performed. When a propagation failure occurs, the underlying SAT engine is invoked: the failure is analysed, a Boolean clause (a “nogood”) that captures the conflict is generated, and the clause is added to the SAT solver’s clause database. The SAT solver then applies Conflict‑Driven Clause Learning (CDCL) to prune the search space, preventing the same infeasible combination of variable assignments from being explored again.

Key technical contributions include:

1. A systematic encoding of RCPSP/max constraints that preserves strong CP propagation while remaining amenable to SAT‑level learning.
2. An integration architecture that allows the CP engine to request clause generation on‑the‑fly, thereby achieving “lazy” clause creation only when needed.
3. Empirical tuning of search heuristics (activity selection, value ordering) that synergise with the learning mechanism, yielding a robust solver across diverse instance characteristics.

The experimental evaluation uses the entire PSPLib benchmark suite (2,340 instances). The LCG solver matched or improved the best known results on 2,337 instances; only three instances fell short of the published optimum, but the gaps were marginal. Of the 631 instances that were still open at the time of the study, the solver closed 573, delivering proven optimal schedules. For the remaining 58 open instances, it tightened the bounds on 51, demonstrating that the learned nogoods significantly reduce the optimality gap even when full optimality cannot be proved within the allocated time.

Performance analysis shows that LCG consistently outperforms pure CP solvers in both runtime and memory consumption, especially on instances with dense precedence networks and tight resource constraints. The clause learning component dramatically reduces the depth of the search tree, while the CP propagation maintains high pruning power at each node. The authors also report that the solver’s memory footprint remains manageable because clauses are generated lazily and discarded when they become irrelevant.

In conclusion, the paper establishes Lazy Clause Generation as a powerful exact method for RCPSP/max, combining the expressive modelling capabilities of CP with the learning strength of modern SAT solvers. The approach is highly robust, scalable to the largest publicly available benchmark sets, and capable of closing a substantial portion of previously unsolved instances. Future work is suggested in extending the framework to stochastic or multi‑objective scheduling, integrating additional resource types (e.g., cumulative with varying capacities), and exploiting parallelism in the clause‑learning process to further accelerate large‑scale industrial applications.