Modeling Adversary Scheduling with QCSP+
Marco Benedetti
Arnaud Lallouet
Jérémie Vautard
Université d’Orléans – LIFO
BP 6759, F-45067 Orléans
Université d’Orléans – LIFO
BP 6759, F-45067 Orléans
Université d’Orléans – LIFO
BP 6759, F-45067 Orléans
marco.benedetti@univ-orleans.fr
arnaud.lallouet@univ-orleans.fr
jeremie.vautard@univ-orleans.fr
ABSTRACT
We consider cumulative scheduling problems in the presence of an adversary. In such setting the scheduler tries to
manage the available resources in so as to meet the scheduling deadline, while the adversary is allowed to change some
parameters—like the resource consumption of some tasks—
up to a certain limit. We ask whether a robust schedule
exists, i.e., one that is guaranteed to work whatever (malicious) actions the opponent may take. We propose to model
this family of decision problems using a variant of Quantified Constraint Satisfaction Problems called QCSP+ , and to
solve them by using the solver QeCode.
the scheduling instance at hand. So, there is a deep interdependence between what the scheduler is allowed to produce
and what the adversary may prefer to attack.
We show that QCSP+ is adequate for both modeling and
solving many variants of such adversary scheduling problem.
The key idea is that actions by the adversary are subject
to universal quantification (in order to capture any possible damaging behavior) under a restriction (used to enforce
consistency with the adversary model). Similarly, the proposals of the scheduler are subject to restricted existential
quantification (where the restriction enforces feasibility).
2.
1.
INTRODUCTION
Classical non-preemptive scheduling problems consist in
finding a starting time for a set of tasks such that precedence and resource constraints are met. Scheduling theory
has been the subject of intensive research in AI and OR.
Many special cases of interest have been identified. For example, handling environment-originated uncertainty is regarded as a major extension to scheduling frameworks. The
introduction of an adversary renders the problem even more
critical, as probabilistic methods are not amenable to reason
on the intentionally malicious behavior of such adversary.
In this paper, we model adversary scheduling problems
with QCSP+ [6], an extension of Quantified Constraint Satisfaction Problems (QCSP) in which restricted quantification is allowed. In our approach, the opponent is not allpowerful. Its disruptive actions have to comply with some
set of constraints, which define an adversary model. Such
constraints are meant to represent the limits of real-world
adversaries. For example, the adversary may be able to
double the resource consumption of no more than half the
involved tasks. Which specific tasks should the adversary
perturb in order to launch the worst possible attack?
The adversary model does not suffice to answer such question. The worst possible attack, if it exists, disrupts every
feasible schedule (by e.g., causing excessive overall resource
consumption). But, the set of feasible schedules depends on
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, to
republish, to post on servers or to redistribute to lists, requires prior specific
permission and/or a fee.
SAC’08 March 16-20, 2008, Fortaleza, Ceará, Brazil
Copyright 2008 ACM 978-1-59593-753-7/08/0003 ...$5.00.
2.1
ADVERSARY SCHEDULING
Background
Scheduling consists in allocating resources to activities
over time. Many kinds of problems are usually considered
in OR literature according to the classification of [11]. Following [3], scheduling is preemptive if activities can be interrupted and resumed, non-preemptive if not, and elastic if
their resource consumption may vary continuously between
0 and the maximum available until they have taken enough
resource to end. From a resource point of view, scheduling is disjunctive if resources are of capacity one (they are
called machines) and cumulative otherwise. In the last case,
each resource has a maximum capacity that cannot be exceeded at any time. Decision scheduling problems consist in
checking whether a given schedule satisfies all the resource
and temporal constraints. Optimization scheduling problems ask to minimize some objective function—typically the
makespan of the schedule. In this paper, we extend the case
of non-preemptive cumulative decision scheduling problems.
Constraint Programming has emerged as a major paradigm to cope with scheduling [3] thanks to its generality
and efficiency. Generality is due to its ability to model most
practical problems by just cumulating suitable constraints.
Efficiency is a result of the integration of powerful OR algorithms at the heart of implementations of global constraints.
A constraint model of scheduling starts by representing
a set of activities. We assume that we have a set A =
{a1 , . . . , an } of activities to schedule. An activity ai is defined by its starting time si , its duration di and its ending
time ei like in Figure 1. Since si +di = ei , only two variables
are required to represent an activity (for modeling purposes
it is sometimes useful to introduce all three).
Two types of constraints are used in scheduling problems.
Temporal constraints define a partial order over activities.
For example, it may be required that aj starts after ai ter-
Figure 1: Representation of an activity.
minates. Let (A, ≺) be a precedence relation over the set
of activities, meaning that for ai , aj ∈ A, if ai ≺ aj , then
ai must be completed before aj can start. This precedence
is easily translated by the constraint ei ≤ sj . Some constraints, such as the earliest or latest starting time allowed
for an activity, can be represented by properly restricting
variable domains. Sometimes, the gap between two activities is constrained to be between a minimum (minij ) and a
maximum (maxij ) value.
The second type of constraints is resource constraints.
Let R = {r1 , . . . , rm } be a set of resources. Each activity ai is expected to require a certain amount cij of resource rj ∈ R during its execution. The maximum available capacity of each resource constraints the amount of
concurrency schedules may exhibit. Let rmaxi be the capacity of the resource ri . For a single resource ri , the
problem can easily be modeled using the global constraint
cumulative([s1 , . . . , sn ], [d1 , . . . , dn ], [c1i , . . . , cni ], rmaxi ) [1].
This constraint ensures that, for a resource rj ∈ R:
0
1
X
∀t ≥ 0, @
cij A ≤ rmaxj
{i | si ≤t≤ei }
Problems involving multiple resources are handled by either enforcing one cumulative constraint per resource, or by
employing a specialized multi-resource constraint [5]. A resource whose capacity changes over time can be simulated
by adding fake activities at fixed times.
In many problems, the duration of an activity is known
in advance and fixed. In such case, the scheduling problem
consists in finding a starting time for all the activities such
that the overall schedule complies with the temporal and resource constraints. In addition, it is usually required to minimize a cost function like the makespan (ending time of the
last activity) or the tardiness (difference between the actual
and expected completion time). Some particular scheduling
problems have been heavily studied, like job-shop problems,
which are used in flexible workshops. In these problems, a
set of machines M defines the resources and activities are
organized in jobs. A job j correspond to a sequence of activities [aj,1 , . . . , aj,nj ] required for building an object.Given
a set of jobs J, the job-shop problem consists in scheduling
the activities of the different jobs in parallel.
2.2
Adversary Scheduling
We introduce here adversary scheduling problems. Two
opponents are involved: The scheduler tries to build a schedule that satisfies all the (temporal and resource) constraints,
while the adversary tries to prevent the formation of a valid
schedule by inflicting some (limited) deterioration on the
problem setting. Let us consider an example with three
activities a1 , a2 , a3 and a resource r such that a1 ≺ a2 ,
d1 = 1, d2 = 2, d3 = 3, c1 = 3, c2 = 2 and c3 = 1. The
schedule must be completed at most by time Tmax = 4.
The tightest valid schedule is given in Figure 2-(i). Assume
that—after the nominal schedule is devised—the adversary
is able to add one unit to the resource consumption of at
most two activities, and let us consider again the schedules
in Figure 2. The maximal possible resource consumption at
each time point of each schedule, under any possible attack
from the adversary, is depicted by using a dashed frontier. It
is easy to see that the makespan-optimal schedule in Figure
2-(i) is subject to a critical attack (one which affects activity a1 and a3 ). The linear schedule depicted in Figure 2-(ii)
is robust w.r.t. attacks but unfortunately fails to meet the
deadline. The schedule in Figure 2-(iii) finishes on time and
is resistant to attacks.
The key point here is that the adversary can invest limited resources in launching attacks, so he has to solve an
optimization task to identify the best one (also depending
on whether he is supposed to act before or after the nominal schedule is unveiled). Note that bounding the number
of tasks whose resource demand can be increased provides
just one example—possibly the simplest one—of adversary
model. We elaborate further on these points in Section 4.
2.3
Related literature
Recently, several papers have considered the impact of
uncertainty in scheduling problems [7, 13, 16, 18]. Most of
these frameworks aim at producing schedules that “behave
well” even if the initial conditions of the problem change
slightly, or if some “enemy” delays tasks or preempts resources for his own use. The uncertainty about task duration, resource consumption or availability is modeled by associating a probability distribution to the uncertain quantities. Such probabilities are taken into account to synthesize
a “probabilistically acceptable” schedule [16]. We consider
here a slightly different case: The adversary is determined
to do its best to break the schedule, within the limits of
his (precisely modeled) resources. So, we cannot expect any
favorable “average behaviour”. We need a worst-case analysis which gives guarantees in all the scenarios consistent
with what the adversary is capable of doing (see the “strong
conformant” notion below).
Multi-objective optimization problems have been studied
in mathematical programming under the name of bilevel programming [4]. In these problems, two players with different
goals make alternate moves acting on the same resources. It
follows that one of the constraints of an optimization problem is itself an optimization problem. The use of bilevel
linear programming to model opponents in project scheduling has been considered in [9]. A QCSP modeling of the
job-shop problem with possibly faulty machines has been
recently proposed [14]. In planning theory, the uncertainty
on effects of actions (caused by the interaction with the environment) leads to consider what could happen in the worst
case. These planning problems are called conformant. In
[10], a distinction is made between weak conformant problems (a solution found may achieve the goal) and strong conformant problems (a solution found is guaranteed to achieve
the goal). Weak conformant problems assume that the adversary hinders the project by chance and he has no will to
harm. Strong conformant problems try to find a solution for
every malicious behavior of an intelligent opponent.
Figure 2: Adversary scheduling example.
3.
QUANTIFIED PROBLEMS
Quantified Constraint Satisfaction Problems [8] are extensions of the classical CSP framework in which some variables
may be universally quantified. In this section, we define
QCSPs and QCSP+ , an extension intended to improve the
modeling capabilities and solving efficiency of QCSPs.
A CSP (V, D, C) is composed of a set V = {v1 , . . . , vn }
of variables ranging over a family of finite domains D =
{d1 , . . . , dn } and a set C = {c1 , . . . , ck } of constraints binding these variables. A solution is a value assignment to all
the variables of V such that every constraint in C is satisfied. The existence of a solution of a given CSP (V, D, C) is
equivalent to the satisfaction of the following formula:
∃v1 ∈ d1 · · · ∃vn ∈ dn . c1 ∧ . . . ∧ ck
The replacement of some of these existential quantifiers by
universal ones leads to the QCSP formalism. A QCSP is a
5-uple (V, D, <, q, C) where V , D and C are inherited from
CSPs, < is a total order on V , and q : V → ∃, ∀ is a function
which associates quantifiers to variables. A QCSP (V, D, <
, q, C) then has a solution iff the following formula is true:
q(v1 )v1 ∈ d1 · · · q(vn )vn ∈ dn . c1 ∧ . . . ∧ ck
In the classical QCSP setting, all variables are quantified,
yielding a closed formula.
The first four elements of a QCSP, namely (V, D, <, q)
define the prefix of the QCSP, which can be denoted as a
chain of quantified variables [q(v1 )v1 ∈ d1 . . . q(vn )vn ∈ dn ]
ordered with respect to <. A solution for such a QCSP
is no longer a simple assignment to every variables in V , as
all the constraints must now be satisfied in several scenarios,
depending on the value assigned to the universally quantified
variables. Such a solution is called a strategy and has the
shape of a set of functions s giving, for each existentially
quantified variable vi a value which is function of the values
taken by all universally quantified variables which precede it
in the order <. A strategy defines a set of scenarios, which
are complete assignments compatible with the strategy. If
all scenarios satisfy the CSP C, the strategy is winning.
A winning strategy is a solution of the QCSP. The name
strategy refers to the intuitive interpretation of QCSPs as a
game between the existential and the universal player.
Deciding the existence of winning strategies for a QCSP is
a PSPACE-complete problem [15], whereas solving a classical CSP is NP-complete. The technique used by most QCSP
solvers is search assisted by a propagation technique which
is the quantified extension of arc-consistency (QAC [8]).
Despite their theoretical expressiveness, pure QCSP have
three main drawbacks: (i) admissible moves in most interesting existential/universal games depend on preceding
moves (in other terms, games have rules... even simple ones
like tic-tac-toe, where it is forbidden to play twice in the
same position). QCSP provide no tool to cleanly restrict
what the universal player is allowed to do (for the existential player it suffices to add the rules as additional constraints). Workarounds demand either ad-hoc extra-QCSP
mechanisms to dynamically restrict variable domains or a
complex rewrite of the model1 . Such “flaw” has been first
identified for QBF, the boolean restriction of QCSP, in [2];
(ii) propagation only applies to the existential variables, thus
reducing its potential power; (iii) since QAC depends on the
quantification pattern of the variables, it requires to implement up to 2n different propagators for a n-ary constraint.
To overcome these problems, QCSP+ were introduced [6].
QCSP+ are an extension of QCSP in which each quantification can be arbitrarily restricted. In a QCSP+ , a CSP
Li is associated to each quantified variable vi in order to
restrict the set of its possible values. Such CSP involves
the variable vi and those preceding vi in <. Formally, the
association of a quantified variable with its restricting CSP
is called a restricted quantifier Qi = (qi , vi , di , Li ). We denote a restricted quantifier as qi vi ∈ di [Li ]. Such restricted
quantifier reads “qi vi ∈ di such that Li holds”.
A QCSP+ is a sequence of restricted quantifiers, followed
by a goal, i.e., a CSP which mentions all the variables introduced by the preceding quantifiers. For example
∃X ∈ dx [Lx ] ∀Y ∈ dy [Lxy ] ∃Z ∈ dz [Lxyz ] . C
reads “exists X ∈ dx such that Lx and for all Y ∈ dy such
that Lxy exists Z ∈ dz such that Lxyz and C”. Note that
from a logic viewpoint, this formula alternates and nests
implications and conjunctions. QCSP+ inherit classical CSP
propagation, and introduces an original mechanism called
cascade propagation [6], which among the other things allows
to prune universal domains. QCSP+ is the input language
for the solver QeCode2 , which is built on top of the CSP
solver GeCode [17]. QeCode is the only quantified solver which
handles the global constraints essential to our models.
4.
ADVERSARY MODELS
We consider two types of adversary problems, according to
the relative order in which the scheduler and the adversary
act. In the first case, a (valid) schedule is proposed, then
the adversary tries to break it. Let s be a schedule (which
1
One workaround consists in reifying all the constraints and then
posting auxiliary disjunctive constraints on the reified variables.
Such rewrite makes the model less readable, obstruct the propagation mechanism, and in several cases (including the one we
consider in this paper) cannot be used just because the reified
version of global constraints is usually not implemented. Another
technique makes use of “shadow” variables [14]. However, such
techniques determines a loss in readability and demands some
assumptions on the structure of the game.
2
QeCode is publicly available at http://www.univ-orleans.fr
/lifo/Members/vautard/research/qecode/index.html.
specifies start time, duration, and resource consumption of
each activity), a be an attack, valid(s) be the CSP which
recognizes valid schedules, possible(a, s) be the adversary
model (i.e., a CSP which recognizes whether the adversary
can launch the attack a on the schedule s), and s(a) be
the schedule resulting from s after the attack a. We are
interested in deciding whether:
∃s[valid(s)] ∀a[possible(a, s)]. valid(s(a))
(2)
If this formula is true the adversary knows that the schedule
cannot be broken. Otherwise, the scheduler knows that the
adversary is powerful enough to devise a critical attack.
These two types of adversary scheduling problems can be
interpreted as two simple one-step games. More general
scheduling interactions (in which the two players interleave
their activities for a number of rounds) can be considered,
but here we limit our attention to the basic patterns.
In both patterns, a schedule is “valid” in the classical
sense, i.e., iff it complies with all the temporal and resource
constraints. Such constraints can be expressed in CSP as
described in Section 2.1. By contrast, no standard model
of “scheduling adversary” exists. In the simplest case, the
adversary model described in Section 2.2 can be considered.
Further examples include adversaries who can, within limits,
elongate tasks or force additional time precedences. Other
threats to schedules are best modeled through a time-based
notion of attack. Consider, for example, an adversary that
can prolong or make more resource-intensive all the activities which take place at time t∗ , but can select only one
such moment t∗ to act (think of the effect of a simultaneous
all-out strike on the operations of a production line). Furthermore, such basic types of adversary can be combined to
obtain arbitrarily complex models of real-world cases.
Here we discuss in detail the QCSP+ model of case (1)
under the assumption that the adversary can impact on a
fraction of the tasks to be scheduled by increasing their resource consumption by a constant factor (see Figure 3).
Let A = {a1 , . . . , an } be a set of activities to be scheduled
and R = {r1 , . . . , rm } be a set of resources. Each activity ai
has a starting time si (with values in the domain dsi ), a duration di (which the adversary cannot extend) and demands
an amount cij of resource rj . Each resource ri has a maximum available capacity rmaxi . The difference between the
starting time of two activities ai and aj such that ai ≺ aj
is constrained to be within the interval [minij ..maxij ].
The adversary is modeled by two parameters α ∈ [0..1]
and β > 0 which represent respectively the fraction of tasks
the adversary can touch, and the factor by which their resource consumption is increased. For example, the adversary
defined by α = 0.1 and β = 0.2 is able to increase by 20% the
resource consumption of 10% of the activities. Note that in
this simple model the schedule plays no role in constraining
possible attacks (i.e., possible(a, s) does not in fact depend
average
median
100
10
(1)
If this formula is true, the scheduler knows that his schedule is safe w.r.t. any attack the (model of the) enemy can
generate. If the formula is false, the adversary knows that
he is sufficiently powerful to break any schedule.
In the second case, the adversary declares its attack first,
then a schedule is produced. In this case, the attack is
schedule-independent, so the adversary model has the simpler form possible(a). We are interested in deciding whether
∀a[possible(a)] ∃s[valid(s)]. valid(s(a))
10-task set
1000
1
0.1
0
20
40
60
80
100
Figure 4: Average and median performances of QeCode on a set of 10-task problems. The X axis represents the percentage of activities touched by the
adversary and the Y axis gives the resolution time.
30-task set
1000
average
median
100
10
1
0.1
0
20
40
60
80
100
Figure 5: Average and median performances of QeCode on a set of 30-task problems. Same conditions
as before. The timeout is 1000 seconds.
on s). In general, such dependency is relevant (think of e.g.,
an adversary that can only touch the first/last activity).
5.
EXPERIMENTS
We have modified two sets of classical multi-resources
scheduling problem instances (without adversary) for which
the optimal makespan Tmax have been previously calculated3 . Only feasible instances were used for our benchmarks. Each instance has been transformed into an adversary scheduling problem of type (1) by means of three
parameters: The parameters α and β introduced in the previous section, and a third parameter γ > 0 which models the
amount of extra time allotted in the adversary setting w.r.t.
the optimal makespan of the original version. The idea is
that schedules gain robustness w.r.t. the attacks we consider
by lowering their degree of parallelism, hence by lengthening
their minimal makespan. We need to grant some extra time
if we ask for robustness.
3
Such instances are described in [12] and are available for download as test-set J10 and test-set J30 at
http://www.wiwi.tu-clausthal.de/en/abteilungen/produktion
/forschung/schwerpunkte/projekt-generator/rcpspmax
∃s1 ∈ ds1 , . . . , sn ∈ dsn , send ∈ dsend
[ {si + di ≤ send | ai ∈ A} ∪ {si + di + minij ≤ sj | ai ≺ aj } ∪ {sj ≤ si + di + maxij | ai ≺ aj } ∪
{cumulative([s1 , . . . , sn ], [d1 , . . . , dn ], [c1i , . . . , cni ], rmaxi ) | i ∈ [1..m]} ]
∀k1 ∈ {0, 1}, . . . , kn ∈ {0, 1}
∀c011 ∈P[c11 ..rmax1 ], . . . , c01m ∈ [c1m ..rmaxm ], . . . , c0n1 ∈ [cn1 ..rmax1 ], . . . , c0nm ∈ [cnm ..rmaxm ]
[ { i=1..n ki = α ∗ n} ∪ {c0ij = cij + ki ∗ (1 + β) | i ∈ [1..n] j ∈ [1..m]} ]
{send ≤ Tmax ∗ (1 + γ)} ∪ {cumulative([s1 , . . . , sn ], [d1 , . . . , dn ], [c01i , . . . , c0ni ], rmaxi ) | i ∈ [1..m]}
Figure 3: Detailed QCSP+ model of an adversary scheduling problem of type (1)
We have run adversary versions of 10-task and 30-task
instances. For each initial instance, 10 adversary problems
are generated, with α = 0, 0.1, . . . , 0.9 (when α = 0 the
opponent can affect no task, so the adversary problem is
equivalent to the initial problem). Each activity affected by
the adversary has 50% extra resource demand (β = 0.5).
The maximum allotted time for the schedule is 10% longer
than the optimal makespan of the initial problem (γ = 0.1).
These tests have been performed on a dual-Opteron at 2.6
GHz equipped with 4 GB of RAM. Timeout is 1000 seconds.
Results are presented in Figure 4 and 5. As expected, we
observe an easy-hard-easy pattern. For very small values
of α (weak adversary) the original schedule (or small variants thereof) is “quickly” recognized as a solution. For large
values of α (40% and more of activities attacked in the 10task test), the adversary is so strong that no robust scheduling is found. In this case, the problem is over-constrained
and propagation quickly shows inconsistence. Intermediate
cases are the hard ones. The presence of the adversary increases dramatically the computation time, even when the
non-adversary version was trivial, while the fraction of positive instances decreases from 100% to 0%. We are investigating whether the large performance penalty is due to the
intrinsic complexity of the problem, or to the need for a better propagation scheme and search heuristics in the solver.
6.
CONCLUSION
We showed how to capture and solve adversary scheduling models using the QCSP+ language. Besides scheduling,
various real-world multi-level problems can be confronted
by the same techniques, as the applicability of bilevel mathematical programming clearly shows [4]. Bilevel programming is often limited to linear constraints and rarely considers the discrete case. In contrast, our approach inherits all the versatility of Constraint Programming in modeling discrete decision problems. Furthermore, both the
time/resource constraints that define valid schedules and the
adversary model are simple to write using basic and global
constraints known by every constraint programmer.
7.
REFERENCES
[1] A. Aggoun and N. Beldiceanu. Extending CHIP in Order to
Solve Complex Scheduling and Placement Problems.
Mathematical and Computer Modelling, 17(7):57–73, April
1993.
[2] C. Ansótegui, C. P. Gomes, and B. Selman. The Achilles’
Heel of QBF. In Manuela M. Veloso and Subbarao
Kambhampati, editors, AAAI, pages 275–281. AAAI Press
AAAI Press / The MIT Press, 2005.
[3] P. Baptiste, C. Le Pape, and W. Nuijten. Constraint-Based
Scheduling. Operations Research and Management Science.
Kluwer Academic Publishers, 2001.
[4] J. F. Bard. Practical Bilevel Optimization: Algorithms and
Applications, volume 30 of Nonconvex Optimization and Its
Applications. Kluwer Academic Publishers, 1999.
[5] N. Beldiceanu and M. Carlsson. A New Multi-resource
Cumulatives Constraint with Negative Heights. In
Pascal Van Hentenryck, editor, CP, volume 2470 of Lecture
Notes in Computer Science, pages 63–79. Springer, 2002.
[6] M. Benedetti, A. Lallouet, and J. Vautard. QCSP Made
Practical by Virtue of Restricted Quantification. In
Manuela Veloso, editor, International Joint Conference on
Artificial Intelligence, pages 38–43, Hyderabad, India,
January 6-12 2007. AAAI.
[7] J. Bidot, T. Vidal, P. Laborie, and J. C. Beck. A General
Framework for Scheduling in a Stochastic Environment. In
Manuela M. Veloso, editor, IJCAI, pages 56–61, 2007.
[8] L. Bordeaux and E. Monfroy. Beyond NP: Arc-Consistency
for Quantified Constraints. In P. Van Hentenryck, editor,
Principles and Practice of Constraint Programming,
volume 2470 of LNCS, pages 371–386, Ithaca, NY, USA,
2002. Springer.
[9] G. G. Brown, W. M. Carlyle, J. Royset, and R. K. Wood.
On the Complexity of Delaying an Adversary’s Project. In
The Next Wave in Computing, Optimization and Decision,
volume 29 of Operations Research/Computer Science
Interfaces Series, chapter 1. Springer, 2005.
[10] M. Ghallab, D. Nau, and P. Traverso. Automated Planning.
Morgan Kaufmann, 2004.
[11] R. Graham, E. Lawler, E. Lenstra, and A. Rinnooy Kan.
Optimization and Approximation in Deterministic
Sequencing and Scheduling: a Survey. Annals of Discrete
Mathematics, 5:287–326, 1979.
[12] R. Kolisch, C. Schwindt, and A. Sprecher. Benchmark
Instances for Project Scheduling Problems, 1998.
[13] S.F. Smith N. Policella, A. Oddi and A. Cesta. Generating
Robust Partial Order Schedules. In M. Wallace, editor,
Principles and Practice of Constraint Programming,
volume 3258, pages 496–511. Springer, 2004.
[14] P. Nightingale. Consistency and the Quantified Constraint
Satisfaction Problem. PhD thesis, University of St
Andrews, 2007.
[15] C. H. Papadimitriou. Computational Complexity. Addison
Wesley, 1994.
[16] N. Policella. Scheduling with Uncertainty: A Proactive
Approach Using Partial Order Schedules. PhD thesis,
University of Rome “La Sapienza”, March 2005.
[17] C. Schulte and G. Tack. Views and Iterators for Generic
Constraint Implementations. In Peter van Beek, editor, CP,
volume 3709 of Lecture Notes in Computer Science, pages
817–821. Springer, 2005.
[18] C.W. Wu, K.N. Brown, and J.C. Beck. Scheduling with
Uncertain Durations: Generating Beta-Robust Schedules
using Constraint Programming. In ICAPS 2006 Workshop
on Constraint Satisfaction Techniques for Planning and
Scheduling Problems, 2006.
Acknowledgements
This work is supported by the CANAR project, ANR-06BLAN-0383.