Modular Constraint Solver Cooperation via Abstract Interpretation

AbstractCooperation among constraint solvers is difficult because different solving paradigms have different theoretical foundations. Recent works have shown that abstract interpretation can provide a unifying theory for various constraint solvers. In particular, it relies on abstract domains which capture constraint languages as ordered structures. The key insight of this paper is viewing cooperation schemes as abstract domains combinations. We propose a modular framework in which solvers and cooperation schemes can be seamlessly added and combined. This differs from existing approaches such as SMT where the cooperation scheme is usually fixed (e.g., Nelson-Oppen). We contribute to two new cooperation schemes: (i) interval propagators completion that allows abstract domains to exchange bound constraints, and (ii) delayed product which exchanges over-approximations of constraints between two abstract domains. Moreover, the delayed product is based on delayed goal of logic programming, and it shows that abstract domains can also capture control aspects of constraint solving. Finally, to achieve modularity, we propose the shared product to combine abstract domains and cooperation schemes. Our approach has been fully implemented, and we provide various examples on the flexible job shop scheduling problem.

Download Full-text

Google vs IBM: A Constraint Solving Challenge on the Job-Shop Scheduling Problem

Electronic Proceedings in Theoretical Computer Science ◽

10.4204/eptcs.306.30 ◽

2019 ◽

Vol 306 ◽

pp. 259-265 ◽

Cited By ~ 1

Author(s):

Giacomo Da Col ◽

Erich Teppan

Keyword(s):

Job Shop ◽

Job Shop Scheduling ◽

Constraint Solving ◽

Scheduling Problem ◽

Job Shop Scheduling Problem ◽

Shop Scheduling

Download Full-text

Evaluation of the Implementation of an Abstract Interpretation Algorithm using Tabled CLP

Theory and Practice of Logic Programming ◽

10.1017/s1471068419000383 ◽

2019 ◽

Vol 19 (5-6) ◽

pp. 1107-1123

Author(s):

JOAQUÍN ARIAS ◽

MANUEL CARRO

Keyword(s):

Logic Programming ◽

Abstract Interpretation ◽

Constraint Logic Programming ◽

Additional Cost ◽

Logic Programs ◽

Semantic Equivalence ◽

Constraint Solver ◽

Abstract Domains ◽

Interpretation Algorithm ◽

Branch Switching

AbstractCiaoPP is an analyzer and optimizer for logic programs, part of the Ciao Prolog system. It includes PLAI, a fixpoint algorithm for the abstract interpretation of logic programs which we adapt to use tabled constraint logic programming. In this adaptation, the tabling engine drives the fixpoint computation, while the constraint solver handles the LUB of the abstract substitutions of different clauses. That simplifies the code and improves performance, since termination, dependencies, and some crucial operations (e.g., branch switching and resumption) are directly handled by the tabling engine. Determining whether the fixpoint has been reached uses semantic equivalence, which can decide that two syntactically different abstract substitutions represent the same element in the abstract domain. Therefore, the tabling analyzer can reuse answers in more cases than an analyzer using syntactical equality. This helps achieve better performance, even taking into account the additional cost associated to these checks. Our implementation is based on the TCLP framework available in Ciao Prolog and is one-third the size of the initial fixpoint implementation in CiaoPP. Its performance has been evaluated by analyzing several programs using different abstract domains.

Download Full-text

Randomized Problem-Relaxation Solving for Over-Constrained Schedules

10.24963/kr.2021/72 ◽

2021 ◽

Author(s):

Patrick Rodler ◽

Erich Teppan ◽

Dietmar Jannach

Keyword(s):

Job Shop ◽

Job Shop Scheduling ◽

Production Capacity ◽

Main Idea ◽

Planning Horizon ◽

Benchmark Problems ◽

Scheduling Problems ◽

Constraint Solver ◽

Set Optimization Problem ◽

Constraint Model

Optimal production planning in the form of job shop scheduling problems (JSSP) is a vital problem in many industries. In practice, however, it can happen that the volume of jobs (orders) exceeds the production capacity for a given planning horizon. A reasonable aim in such situations is the completion of as many jobs as possible in time (while postponing the rest). We call this the Job Set Optimization Problem (JOP). Technically, when constraint programming is used for solving JSSPs, the formulated objective in the constraint model can be adapted so that the constraint solver addresses JOP, i.e., searches for schedules that maximize the number of timely ﬁnished jobs. However, also highly specialized solvers which proved very powerful for JSSPs may struggle with the increased complexity of the reformulated problem and may fail to generate a JOP solution given practical computation timeouts. As a remedy, we suggest a framework for solving multiple randomly modiﬁed instances of a relaxation of the JOP, which allows to gradually approach a JOP solution. The main idea is to have one module compute subset-minimal job sets to be postponed, and another one effectuating that random job sets are found. Different algorithms from literature can be used to realize these modules. Using IBM’s cutting-edge CP Optimizer suite, experiments on well-known JSSP benchmark problems show that using the proposed framework consistently leads to more scheduled jobs for various computation timeouts than a standalone constraint solver approach.

Download Full-text