Get Principles and Practice of Constraint Programming 26th International Conference CP 2020 Louvain La Neuve Belgium September 7 11 2020 Proceedings Helmut Simonis Free All Chapters
Get Principles and Practice of Constraint Programming 26th International Conference CP 2020 Louvain La Neuve Belgium September 7 11 2020 Proceedings Helmut Simonis Free All Chapters
com
https://textbookfull.com/product/art-nouveau-animal-designs-and-
patterns-60-plates-in-full-color-dover-pictorial-archive-2nd-edition-
verneuil/
textbookfull.com
Until Now: Happily Ever Alpha World and Swift Family
Crossover 1st Edition Leslie Pike & Boom Factory
Publishing [Pike
https://textbookfull.com/product/until-now-happily-ever-alpha-world-
and-swift-family-crossover-1st-edition-leslie-pike-boom-factory-
publishing-pike/
textbookfull.com
https://textbookfull.com/product/how-to-fry-everything-a-fried-
cookbook-filled-with-delicious-fried-recipes-2nd-edition-booksumo-
press/
textbookfull.com
https://textbookfull.com/product/acute-stroke-management-in-the-
first-24-hours-a-practical-guide-for-clinicians-maxim-mokin/
textbookfull.com
https://textbookfull.com/product/paint-play-explore-first-edition-rae-
missigman/
textbookfull.com
The Battle of the Classics How a Nineteenth Century Debate
Can Save the Humanities Today 1st Edition Eric Adler
https://textbookfull.com/product/the-battle-of-the-classics-how-a-
nineteenth-century-debate-can-save-the-humanities-today-1st-edition-
eric-adler/
textbookfull.com
Helmut Simonis (Ed.)
LNCS 12333
Founding Editors
Gerhard Goos
Karlsruhe Institute of Technology, Karlsruhe, Germany
Juris Hartmanis
Cornell University, Ithaca, NY, USA
123
Editor
Helmut Simonis
Insight Centre for Data Analytics,
School for Computer Science
and Information Technology
University College Cork
Cork, Ireland
This Springer imprint is published by the registered company Springer Nature Switzerland AG
The registered company address is: Gewerbestrasse 11, 6330 Cham, Switzerland
Preface
This volume contains the papers presented at the 26th International Conference on
Principles and Practice of Constraint Programming (CP 2020), held during
September 7–11, 2020. The conference was originally planned to be held at UC
Louvain, Belgium. Due to the COVID-19 pandemic, we were forced to run the con-
ference as a virtual event instead.
There were 122 submissions for the conference. The Program Committee decided to
accept 55 papers. As is customary for the CP conference series, we offered multiple
tracks for submitted papers to widen the scope of the conference and attract papers at
the interface of Constraint Programming and other disciplines. This year there were
tracks for:
– Technical Track
– Application Track
– Constraint Programming, Data Science and Machine Learning
– Testing and Verification
– Constraint Programming and Operations Research
– Computational Sustainability
I want to thank the application track chair, Andreas Schutt (Data61, Australia), the
CP/ML track chair, Michele Lombardi (DISI, University of Bologna, Italy), and the
chair for the Testing and Verification track, Nadjib Lazaar (LIRMM, France), for their
dedicated work. They selected and invited track specific Program Committees, helped
with the paper assignment across the different tracks, and managed the discussion and
final paper selection after the review phase.
The paper selection in the other tracks was supported by a Senior Program
Committee, who not only encouraged and guided the discussion of papers during
reviewing, but also provided meta-reviews as summaries and basis for the paper
selection.
The Program Committee for this year’s conference faced a special challenge as the
time given for reviewing was very compressed. The original submission deadline was
shifted by more than five weeks to counteract the impact of the COVID-19 lock-down
in many countries around the world. I was very impressed by, and thankful for, the
quality and detail of the reviews provided.
The reviewer assignment was decided for all tracks at the same time, to balance the
workload of all reviewers. For this, we used an extended version of a Constraint
Programming model developed and used last year by the CP 2019 program chairs,
Thomas Schiex and Simon de Givry.
Besides the paper tracks, the conference also had many other elements, handled by
special chairs. Maria-Andreina Francisco Rodriguez (Uppsalla University, Sweden)
organized the workshops on the first day of the conference, Lars Kotthoff (University
of Wyoming, USA) selected three tutorials for the main conference, and Edward Lam
vi Preface
Program Committee
Ignasi Abío Barcelogic, Spain
Deepak Ajwani University College Dublin, Ireland
Özgür Akgün University of St Andrews, UK
Carlos Ansótegui Universitat de Lleida, Spain
Ekaterina Arafailova Tesco, UK
Behrouz Babaki Polytechnique Montreal, Canada
Sébastien Bardin CEA LIST, France
Roman Barták Charles University, Czech Republic
Chris Beck University of Toronto, Canada
Nicolas Beldiceanu IMT Atlantique (LS2N), France
Gleb Belov Monash University, Australia
Stefano Bistarelli Università di Perugia, Italy
Miquel Bofill Universitat de Girona, Spain
Andrea Borghesi University of Bologna, Italy
Ken Brown University College Cork, Ireland
David Browne Insight Centre for Data Analytics, Ireland
Hadrien Cambazard G-SCOP, Grenoble INP, CNRS, Joseph Fourier
University, France
Roberto Castañeda Lozano The University of Edinburgh, UK
Berthe Y. Choueiry University of Nebraska-Lincoln, USA
Andre Augusto Cire University of Toronto, Canada
Laura Climent University College Cork, Ireland
Martin Cooper IRIT, Université Paul Sabatier, France
Patrick De Causmaecker UC Leuven, Belgium
Allegra De Filippo DISI, University of Bologna, Italy
viii Organization
Additional Reviewers
Technical Track
Solving the Group Cumulative Scheduling Problem with CPO and ACO . . . . 620
Lucas Groleaz, Samba N. Ndiaye, and Christine Solnon
Application Track
1 Introduction
In the past decade the interest in solving string constraints has considerably
grown in disparate application domains such as test-case generation, software
analysis and verification, model checking, web security, database query process-
ing, bionformatics (see, e.g., [3,8,9,11–15,18,24,29]).
Among the most effective paradigms for string constraint solving we men-
tion Satisfiability Modulo Theory (SMT), which relies on (extensions of) the
theory of word equations, and Constraint Programming (CP), which basically
uses an unfolding-based approach to eventually decompose a string variable into
sequences of integer variables representing the string characters.
A promising CP approach, on which this paper focuses, is based on dashed
strings. Given a fixed finite alphabet Σ and a maximum string length λ, dashed
strings are a particular class of regular expressions denoting sets of concrete
strings W ⊆ {w ∈ Σ ∗ | |w| ≤ λ} through the concatenation of distinct sets of
characters called blocks. Dashed strings are used to represent in a compact way
the domain of string variables without eagerly unfolding them into λ integer
variables. This can make a huge difference, especially when λ is big.
Several algorithms for dashed strings have been defined to propagate string
constraints like (in-)equality, concatenation, length, or regular expression mem-
bership. Most of them are based on the concept of dashed strings equation [7].
In this paper, we focus on a well-known constraint frequently occurring in
problems derived from software verification and testing: the Replace constraint.
c Springer Nature Switzerland AG 2020
H. Simonis (Ed.): CP 2020, LNCS 12333, pp. 3–20, 2020.
https://doi.org/10.1007/978-3-030-58475-7_1
4 R. Amadini et al.
Despite being a construct heavily used in modern programming, very few solvers
have implemented Replace, and its variants, due its non trivial semantics. For
this reason, few benchmarks exist.
Given an input string x, a query string q and a new string q we have that
Replace(x, q, q ) is the string obtained by replacing the first occurrence of q in
x with q (Replace(x, q, q ) = x if q does not occur in x). Common variants
are Replace-Last (that replaces the last occurrence of the query string) and
Replace-All (that replaces all the occurrences of the query string).
At present, no dashed string propagator has been defined for Replace (in
[5] it is simply decomposed into other string constraints). This approach is sound
but certainly improvable. In this work we define a unified propagation algorithm
that (i) improves the precision and the efficiency of Replace propagation, and
(ii) is general enough to propagate Replace-Last and Replace-All. The
latter in particular cannot be decomposed into basic constraints because we do
not know a priori how many times the query string occurs.
Empirical results show that the approach we propose significantly outper-
forms the performance of the decomposition approach and state-of-the-art SMT
solvers.
Paper structure. In Sect. 2 we give preliminary notions. In Sect. 3 we explain
how we propagate Replace and related constraints. In Sect. 4 we report the
empirical results, before discussing the related works in Sect. 5 and concluding
in Sect. 6.
2 Dashed Strings
Let Σ be a finite alphabet and Σ ∗ the set of all the strings over Σ. We denote
with the empty string and with |w| the length of w ∈ Σ ∗ . We use 1-based
notation for (dashed) strings: w[i] is the i-th symbol of w for i = 1, . . . , |w|.
The concatenation of v, w ∈ Σ ∗ is denoted by v ·w (or simply vw) while wn =
n−1
ww is the concatenation of w for n > 0 times (w0 = ). The concatenation
of V, W ⊆ Σ ∗ is denoted with V · W = {vw | v ∈ V, w ∈ W } (or simply V W )
while W n = W W n−1 is the concatenation of W for n times (W 0 = {}). In this
work we focus on bounded-length strings, i.e., we fix an upper bound λ ∈ N and
only consider strings in SλΣ = {w ∈ Σ ∗ | |w| ≤ λ}.
A dashed string X = S1l1 ,u1 · · · Sklk ,uk is a concatenation of k = |X|> 0 blocks
such that, for i = 1, . . . , k: (i) Si ⊆ Σ; (ii) 0 ≤ li ≤ ui ≤ λ; (iii) ui + j=i lj ≤ λ.
For each block X[i] = Sili ,ui we call Si the base and (li , ui ) the cardinality,
where li = lb(Sili ,ui ) is the lower bound while ui = ub(Sili ,ui ) is
the upper bound
n
of X[i]. We
n extend this notation to dashed strings: lb(X) = i=1 lb(X[i]) and
ub(X) = i=1 ub(X[i]). Intuitively, lb(X) and ub(X) are respectively the lower
and the upper bound on the length of each concrete string denoted by X.
The primary goal of dashed strings is to compactly represent sets of strings,
so we define a function γ such that γ(S l,u ) = {w ∈ S ∗ | l ≤ |w| ≤
u} ⊆ SλΣ is the language denoted by block S l,u (in particular γ(∅0,0 ) = {}
for the null block ∅0,0 ). We extend γ to dashed strings: γ(S1l1 ,u1 · · · Sklk ,uk ) =
Dashed Strings and the Replace(-all) Constraint 5
(γ(S1l1 ,u1 ) . . . γ(Sklk ,uk )) ∩ SλΣ . Blocks of the form S 0,u are called nullable because
∈ γ(S 0,u ). A dashed string X is known if γ(X) = {w}, i.e., it represents a
single, “concrete” string w ∈ SλΣ .
We call DSλΣ the set of all the dashed strings. Note that, while SλΣ is finite,
λ
DSΣ is countable: λ bounds the cardinalities of the blocks, but not the number
of blocks that may appear in a dashed string. For example, given distinct char-
acters a, b ∈ Σ we can generate an infinite sequence of dashed strings in DSλΣ :
{a}0,1 {b}0,1 , {a}0,1 {b}0,1 {a}0,1 , {a}0,1 {b}0,1 {a}0,1 {b}0,1 , . . . .
A dashed string X = S1l1 ,u1 S2l2 ,u2 · · · Sklk ,uk is normalised if: (i) Si = Si+1 ,
(ii) Si = ∅ ⇔ li = ui = 0, (iii) X = ∅0,0 ∨ Si = ∅ for i = 1, . . . , k. The
operator Norm normalises a dashed string (note γ(X) = γ(Norm(X))). We
denote the set of normalised dashed strings as DSλΣ = {Norm(X) | X ∈ DSλΣ }.
Normalisation is fundamental to remove a large number of “spurious” dashed
strings from DSλΣ , i.e., distinct dashed strings denoting the same language. If
not otherwise specified, we will always refer to normalised dashed strings.
We define the partial order such that X Y ⇔ (X = Y ∨ γ(X) ⊂ γ(Y ))
to model the relation “is more precise than or equal to” between dashed strings,
i.e., we consider X more precise than Y if γ(X) ⊂ γ(Y ).1 Note that the poset
(DSλΣ , ) is well-founded but not a lattice: in general, we may not be able to
determine the dashed string which best represents two or more concrete strings.
For example, the set {ab, ba} has two minimal representations {a}0,1 {b}1,1 {a}0,1
and {b}0,1 {a}1,1 {b}0,1 which are not comparable according to .
From a graphical perspective, we can see a block S l,u as a continuous segment
of length l followed by a dashed segment of length u − l. The continuous one
indicates that exactly l characters of S must occur in each concrete string of
γ(X); the dashed one indicates that k ≤ u − l characters of S may occur.
Consider dashed string X = {B,b}1,1 {o}2,4 {m}1,1 {!}0,3 of Fig. 1. Each string of
γ(X) must start with ‘B’ or ‘b’, followed by 2 to 4 ‘o’s, one ‘m’, and 0 to 3 ‘!’s.
1
is not defined as X Y ⇐⇒ γ(X) ⊆ γ(Y ) because otherwise would be
a pre-order but not a partial order in general, e.g., if λ = 2 then X = {a, b, c}0,2
and Y = {a, b}0,2 {b, c}0,2 {a, c}0,2 are such that γ(X) ⊆ γ(Y ) and γ(Y ) ⊆ γ(X) so
X Y and Y X but X = Y .
Visit https://textbookfull.com
now to explore a rich
collection of eBooks, textbook
and enjoy exciting offers!
6 R. Amadini et al.
For brevity, we also define X[..., P ] = X[(0, 0), P ] and X[P, ...] = X[P, (k, uk )].
For example, in Fig. 1 we have that region X[(2, 1), (2, 4)] is {o}1,3 while
X[(2, 3), (4, 2)] = {o}0,1 {m}1,1 {!}0,2 . Region X[(2, 2), ...] is {o}0,2 {m}1,1 {!}0,3
while X[..., (4, 1)] is {B,b}2,4 {o}2,4 {m}1,1 {!}0,1 .
Positions are used to implement a fundamental operation between dashed
strings, on which the propagator Replace propagator relies: the dashed string
equation. Equating X and Y means looking for a refinement of X and Y includ-
ing all the strings of γ(X)∩γ(Y ) and removing the most strings not belonging to
γ(X) ∩ γ(Y ). In other words, we look for a minimal—or at least small enough—
dashed string denoting all the concrete strings of γ(X) and γ(Y ) (the smallest
dashed string does not always exist because (DSλΣ , ) is not a lattice).
In [7] the authors introduced a sweep-based algorithm, that here we will call
Equate2 , such that: (i) if Equate(X, Y ) = ⊥, then γ(X) ∩ γ(Y ) = ∅; (ii)
if Equate(X, Y ) = (X , Y ) = ⊥, then X X, Y Y and γ(X) ∩ γ(Y ) =
γ(X )∩γ(Y ). In a nutshell, Equate(X, Y ) matches each block X[i] against each
block of Y to determine its earliest/latest start/end positions in Y , and uses this
information to possibly refine X[i] into more precise block(s) X [i] X[i].
For example, consider matching block B = {o, m, g}2,6 against dashed string
X of Fig. 1 starting from position (0, 0). The earliest start of B is (2, 0) (it cannot
match X[1] = {B, b}1,1 because its base does not contain any B or b) and the
earliest end is (2, 2) (B contains at least 2 characters); the latest start is (2, 3)
because B cannot finish after latest end position (4, 0) (it cannot match {!}0,3 ).
This means that if B is the i-th block of a dashed string Y that we are equating
with X, then the prefix Y [..., i−1] has to match {B, b}1,1 and the suffix Y [i+1, ...]
has to match {!}0,3 (otherwise, Equate(X, Y ) = ⊥).
The region between earliest start and latest end is called feasible region,
while the region between latest start and earliest end is the mandatory region.
In the above example, the feasible region is X[(2, 0), (4, 0)] = {o}2,4 {m}1,1 while
mandatory region is null (latest start comes after earliest end). This information
enables the refinement of B into the more precise blocks {o}2,4 {m}1,1 .
2
In [7] it was called Sweep to distinguish it the Cover equation algorithm.
Dashed Strings and the Replace(-all) Constraint 7
start (resp. end) of X[i] in Y [P0 , ...] (see pseudo-code in Fig. 2). If X[i] cannot
match any block of Y [P0 , ...], then Ps = Pe = (|Y | + 1, 0). Dually, Push− works
“backwards” to find (Ps , Pe ) in Y [..., P0 ] from right to left.
In Fig. 1, if P0 (3, 0) then Push+ ({m}1,2 , X, P0 ) = ((3, 0), (4, 0))
and Push− ({m}1,2 , X, P0 ) = ((0, 0), (0, 0)); otherwise, if P0 (3, 0), then
we have Push+ ({m}1,2 , X, P0 ) = ((5, 0), (5, 0)) and Push− ({m}1,2 , X, P0 ) =
((4, 0), (3, 0)).
Analogously, a pair of Stretch functions are used for “latest” positions:
Stretch+ (X[i], Y, P0 ) is the latest position (left-to-right) where X[i] can match
Y starting from P0 (while Stretch− works right-to-left, see Fig. 3).3
In Fig. 1, for example, if P0 = (2, 1) then Stretch+ ({o,m,g}1,8 , X, P0 ) =
(3, 1) and Stretch− ({o,m,g}1,8 , X, P0 ) = (1, 1). If instead P0 = (0, 0)
then both functions return P0 because Stretch− cannot go further left and
Stretch+ cannot go further right since {o,m,g}1,8 does not match {B,b}1,1 .
3 Propagating Replace
3
Push and Stretch are not dual. For example, when incompatible blocks are found,
Push moves on (Fig. 2, line 9) while Stretch returns (Fig. 3, line 13).
4
In [5] the order of Replace arguments is different. In this paper we change the
notation to be consistent with SMT-LIB specifications.
Dashed Strings and the Replace(-all) Constraint 9
Fig. 4. Generalised propagator for Replace∗ . Line 28 separates the particular cases
from the general case.
10 R. Amadini et al.
Updated editions will replace the previous one—the old editions will
be renamed.
1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.
1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.
• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
about donations to the Project Gutenberg Literary Archive
Foundation.”
• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.
1.F.
1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.
Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.
Most people start at our website which has the main PG search
facility: www.gutenberg.org.