caed d2: modelling the turnaround processcaed d2 ... · literature review, the theoretical work is...

National Aerospace Laboratory NLRNational Aerospace Laboratory NLRNational Aerospace Laboratory NLRNational Aerospace Laboratory NLR

Delft University of TechnologyDelft University of TechnologyDelft University of TechnologyDelft University of Technology

CAED D2: Modelling the Turnaround ProcessCAED D2: Modelling the Turnaround ProcessCAED D2: Modelling the Turnaround ProcessCAED D2: Modelling the Turnaround Process

CARE INO III: The Co-ordinated Airport through

Extreme Decoupling

Pieter Buzing

Lian Ien Oei

Léon Planken

Cees Witteveen

No part of this report may be reproduced and/or disclosed, in any form or by any means without the prior written permission of the owner.

Customer: Eurocontrol Contract number: 2366111 Owner: Eurocontrol Date: 19 April 2007 Version: 2.0

-2-

CAED D1: LITERATURE SURVEY

-3-


Summary

The Simple Temporal Problem (STP) formalism has been developed for representation of and

reasoning with temporal constraint satisfaction problems. Several extensions of the formalism

exist, with which more complex problems can also be modelled. In the Temporal Decoupling

Problem (TDP), an STP is partitioned into sub-problems, that can be solved independently of

each other. This report describes and gives an overview of research on the Simple Temporal

Problem, some of its extensions, methods for solving one of those extensions and the Temporal

Decoupling Problem.

-4-


Contents

1 Introduction 6

2 The Simple Temporal Problem 9 2.1 Temporal problems 9

2.2 The STP model 11

2.2.1 Time point variables and temporal constraints 11

2.2.2 Temporal reference point and unary constraints 12

2.2.3 STPs and temporal plans 12

2.2.4 Graph representation of STPs 13

2.2.5 The d-graph 15

2.3 Solving STPs 16

2.3.1 Solutions of an STP 16

2.3.2 Finding particular solutions 16

2.3.3 Finding other solutions: partial solutions and decomposability 17

2.3.4 Finding other solutions 19

2.4 Dealing with uncontrollable events: offline and online dispatching 19

2.4.1 Finding solutions offline 19

2.4.2 Finding solutions online 19

2.5 Summary 20

3 STP extensions 22 3.1 Disjunctions 23

3.1.1 The Temporal Constraint Satisfaction Problem 23

3.1.2 The Disjunctive Temporal Problem 24

3.2 Preferences 24

3.3 Resources 27

4 Solving extended STPs 30

4.1 The conventional method 30

4.2 Introducing local search 32

4.3 Local search techniques 32

4.4 4.4 Local search in the temporal domain 34

4.5 Conclusion 36

5 The Temporal Decoupling Problem 37

-5-


5.1 What is the Temporal Decoupling Problem? 38

5.2 Solving TDPs 40

5.3 Extensions 42

5.4 Summary 44

6 Conclusions 45 6.1 Summary 45

6.2 Future Research 46

7 References 48

Appendix A 51 Notes on Chapter 2 51

Notes on Chapter 3 58

Notes on Chapter 5 60

-6-


1 Introduction

At airports, many different airport processes can be distinguished to play a role in the safe and

expedient handling of aircraft. For the co-ordination of these processes, planning and scheduling

play a crucial role. Often sophisticated schedules have to be developed in order to meet the high

efficiency requirements and deal with the limited availability of resources. Yet, even though the

implementation of such specialised planning software has led to a considerable performance

gain, inefficiencies are still encountered. This has to do with the dynamic and distributed nature

of the Air Traffic Management (ATM) process, and these aspects are not fully represented in

today’s planning systems.

In the Co-ordinated Airport through Extreme Decoupling (CAED) project, of which this

document forms part, a new approach towards planning is proposed. In this approach, the

existence of many different actors, each responsible for its own set of processes, is recognised.

These actors, all operating in the same airport domain, depend on each other’s actions and

plans—but typically prefer to plan their own processes independently as much as possible. After

all, each actor may have its own goals, resources, performance issues, and business objectives.

In the approach proposed, these actors are allowed to plan their processes locally as much as

possible.

Such processes can be modelled as temporal problems. In a temporal problem, events are

associated with temporal intervals that represent the time period during which the event may

occur. Given some temporal information, e.g., about the duration of a certain action or about

relationships between two events, the problem is to determine at which times the events must be

dispatched. Additionally, the local planner has to make sure that his temporal plan is not in

conflict with plans of other actors at the airport. To achieve this, co-ordination between actors is

required.

Broadly speaking, co-ordination can be achieved by either communication or decoupling. In this

project, we dismiss the former option since (i) it will hamper the overall system performance,

(ii) the ATM business case does not allow sharing of private information, (iii) a lot of research

has already been conducted in this direction. We therefore embark on the second option, where

the local plans are made—to arbitrary extent—independent from one another. Thus, no further

co-ordination is required between actors once the local plans have been established.

Planning and scheduling tools are generally designed using a specialised domain model that fits

the application best. The fact that each software tool thus has its own temporal model does not

-7-


help in system alignment and integration. For this reason, we chose a general approach—to be

applicable, in principle, to many different ATM problem domains. In this document, the

theoretical building blocks required for this approach are described. A basic form is proposed

that can represent—in principle—any type of temporal constraints for any ATM domain:

scheduled departure times, slot allocation times, runway separation times, ground handling

service times, etc. This basic form has some nice mathematical features of its own, but it also

enables us to design a decoupling scheme that is generic (i.e., is not restricted to a single

software tool) and contains all the properties (e.g., soundness, fairness) that we want. In

Deliverable D2 [6], this basic form and decoupling scheme is applied to an example domain: the

turnaround process.

In the 1970s and 1980s, a lot of work in the Artificial Intelligence field was aimed at temporal

reasoning, e.g. [1][28]. Even though this work has greatly influenced today’s expert systems,

the expressiveness and performance of such systems was insufficient for most practical

domains. In 1991, however, a new temporal model was proposed by Dechter, Meiri and Pearl

[5]. In their Simple Temporal Problem (STP) model, there is a set of variables that represent the

time points, and a set of constraints, that represent the relations between these variables. Each

constraint is associated with an interval that indicates the allowed temporal distance between

two variables. A solution to an STP is an assignment of times to variables, such that all

constraints are satisfied. This clear and flexible formalism tackled most of the problems of the

1970s and 1980s. The temporal framework has been popular ever since.

One of the reasons for the popularity of STPs was the ease with which extensions could be fit

on top of it. These extensions include disjunctions that enable the designer to encode planning

choices, or preference information that can be used to distinguish solutions of different quality.

We will dedicate a section of this literature report to these disjunctive temporal problems. Other

variants which seem less promising for our purposes will only briefly be touched upon.

Another merit of the STP framework is the applicability of well-known (and successful)

constraint satisfaction techniques. The research field concerning the Constraint Satisfaction

Problem (CSP) has provided efficient methods that enable us to reason about temporal

constraints, e.g. [30]. It is for example not hard to decide whether a collection of constraints can

constitute a consistent plan, or to actually extract such a plan. Also, a decoupling scheme can be

implemented at little cost, reducing or eliminating the interdependencies between local planners.

The PhD thesis of Luke Hunsberger [10] should be regarded as the main theoretical contribution

to this line of research and can therefore be seen as the starting point of this research.

-8-


This document provides an overview of literature on Simple Temporal Problems, extensions to

this temporal planning methodology and approaches for solving them, and decoupling. In this

literature review, the theoretical work is related to examples taken from the ATM domain. The

reader should be aware, however, that in the ATM domain little research has been devoted to

decoupling in the way we propose it. Projects like LEONARDO, where the different ATC

planners are extended with communication tools, do share our goal of autonomous parties

actively working together, but start at a very domain specific stage, e.g., [27]. Since our

approach is more aimed at the original (basic) time constraints instead of already established

flight schedules, it is hard to draw a comparison here. Note furthermore that our endeavour is

more mathematically inspired and that “decoupling” should be interpreted in the strictest

possible way; some approximation algorithms and other approaches could—more or less—be

seen as decoupling techniques to a lesser extent, but we choose not to include those in our

survey.

The outline of this report is as follows: Chapter 2 gives an introduction to temporal problems

and describes the STP formalism. Chapter 3 gives an introduction to some extensions of the

formalism which can be used to model more complicated problems. Chapter 3 describes

methods for tackling one of the extended methods described in Chapter 4. Chapter 5 describes

the Temporal Decoupling Problem. Finally, in Chapter 6 the conclusions of this literature study

are formulated.

-9-


2 The Simple Temporal Problem

We start this chapter with an introduction to temporal problems to make clear what type of

problems we want to address. We introduce a simple leading example that will be used to

illustrate the ideas and techniques that will be presented in this report. This example is expanded

upon in later chapters. Next, we introduce the well-known Simple Temporal Problem (STP)

model which has been developed for easy representation of and tractable reasoning with a

specific class of temporal problems. Section 2.2 gives a precise description of the STP model

and introduces several alternative representations of STPs. In Sections 2.3 and 2.4 some basic

methods for solving STPs are described. Section A in the Appendix discusses several

improvements of these basic solution methods.

The main ideas in this chapter are taken from Dechter, Meiri and Pearl [5], and from Pollack

and Tsamardinos [18].

2.1 Temporal problems

In any application domain where activities take place that involve change, time is an essential

ingredient of problem solving. In general, we call a problem a temporal problem when time

constraints are involved. Examples of such temporal problems range from airport planning,

crew scheduling, gate-assignment to trip planning, scheduling of meetings etcetera. Time

constraints can be expressed as in the following sentences:

• “Passengers have to pack their suitcases before they go on vacation.”

• “Passengers have to be at the airport at least 2 hours before their flight leaves.”

• “The gate closes at 03:15 PM.”

In these examples we used qualitative constraints, such as “before', and quantitative constraints,

such as “at 03:15 PM”. As we will see below, if we allow quantitative constraints to contain

indefinite values like ∞ or −∞, qualitative temporal constraints can always be expressed as

quantitative constraints. Therefore, in this report, we will not distinguish them and we will

concentrate on quantitative constraints only.

Before we elaborate on the formalism in more detail, we present an example. This example

introduces a temporal problem that will be used to illustrate the ideas and theorems in this

report. Throughout this report it will be modified and extended, to incorporate examples of the

various problems that can be solved by techniques presented in this report.

-10-


Example 2.1 Alice goes on vacation tomorrow. Her flight departs at 03:30 PM and check-in

closes half an hour before that. Alice does not want to spend more than two and a half hours at

the airport. She wants to know at what time she should arrive at the airport. Thus the goal is to

find a schedule that allows her to be at the airport before check-in closes, without having to

wait longer than she is willing to.

In this example three events can be distinguished: Alice's arrival at the airport, the moment

check-in closes, and the moment her flight departs. It is easy to see that the check-in closes at

03:00 PM, so one possible plan is for Alice to arrive at the airport at 02:00 PM. However, she

may also arrive a little earlier or later, as long as it is between 01:00 PM (2½ hours before take-

off) and 03:00 PM. This shows that a problem may have more than one solution.

Given a temporal problem, we first want to know on the basis of the information given whether

it is consistent, that is whether there exists any solution at all to the problem, and next we want

to derive new information from it. For example, given the information about Alice, we want to

answer questions such as:

• “Is it possible that Alice will still be at home at noon?”

• “At what time should she take the train in order to catch her flight?”

Typically, such temporal problems are formulated as (temporal) constraint satisfaction

problems, and general constraint satisfaction methods may be used to check consistency and to

search for solutions of such temporal problems. To exploit, however, the additional structure of

timed information we often prefer to specialise these general techniques to temporal constraint

problems. The basic ingredients of temporal problems consist of events and timed relations

between events. In the scenario above, being at the airport and departure of a flight are events.

There is a timed relation between them since the first event has to occur at least two hours

before the second one occurs.

It is very convenient in modeling such scenarios to use a time point variable x, that is a variable

taking values in some time domain, to uniquely represent each event. Temporal constraints may

exist between these variables. As the previous example shows, temporal constraints between

two events may be formulated in a relative way (“before” or “at least 2 hours before”), or if only

one event is involved it may contain a reference to absolute time (“at 03:30 PM”). To model

actions a having a duration, we use two events (time variables), namely the start sa and the end

ea of the action, and a temporal constraint that restricts the duration d of the action. For example,

-11-


the information that an action a has a maximal duration of d time units can be modeled by the

constraint ea − sa ≤ d.

Using this time constraint representation, a consistency check comes down to answering the

question whether there exists an assignment to time point variables, such that all constraints can

be satisfied. Queries about the temporal information can be answered by adding a new

constraint and asking for a solution to the new set of constraints.

As we remarked above, temporal problems can be conveniently represented as general

constraint satisfaction problems, with temporal constraints that are defined for time-point

variables. Most of these problems are hard to solve. With the applications we have in mind, we

aim at efficient solution techniques for temporal problems. It turns out that by concentrating on

special cases of a more general temporal problem, sometimes one can find very efficient

solution methods for these problems. One of these special cases is the Simple Temporal

Problem (STP) model. This model has been introduced by Dechter, Meiri and Pearl [5] in 1991.

It can be used for the representation of and efficient reasoning with such temporal problems. We

will discuss the STP model in the next section.

2.2 The STP model

2.2.1 Time point variables and temporal constraints

Let us now look into the details of the Simple Temporal Problem (STP). An STP, like any

constraint satisfaction problem, consists of a finite set X = { x0, …, xn } of variables and a set of

constraints C = { cij | i, j ∈{0, …, n} } between these variables.

A variable xi is called a time point variable and represents a unique event that in an STP is

characterised by its time of occurrence. So each variable xi has to take a value in a fixed time

domain T.

A constraint cij relates two events xi and xj and indicates the allowed distances between the time

points of the events represented by xi and xj. Every such a constraint cij is represented by a time

interval I ij = [aij, bij] abbreviating the inequalities aij ≤ xj − xi ≤ bij or the expression xj − xi ∈ [aij,

bij]. Such a constraint expresses that xj has to occur at least aij time units and at most bij time

units after xi.

If aij and bij are both negative, this means that xj has to occur before xi instead; if aij is negative

-12-


and bij is positive, xj may occur the specified amounts of time before or after xi or even at the

same time.

Example 2.2 If we want to express that an event x1 has to occur before an event x2, the

difference x2 − x1 should be positive. Hence, the corresponding constraint would be c1,2 = [0,∞].

If we require x3 to occur at least 2 time units after x4, this constraint can be expressed by either

c3,4 = [− ∞, −2] or c4,3 = [2, ∞]. The constraint that x5 must take place anytime between 4 time

units before and 7 time units after x6 can be represented as c5,6 = [−7,4] or, equivalently, as c6,5

= [−4,7].

2.2.2 Temporal reference point and unary constraints

The time point x0 is a special time point, called the temporal reference point, that denotes an

agreed-upon fixed point in time (for example, midnight UTC on 1 March 1963). Usually it is

assigned the value 0. Therefore it is also called the zero time-point variable, and sometimes is

referred to as z.

Using these temporal reference points, we can represent unary constraints, which restrict the

domain of a single variable xi, as binary constraints c0i between the temporal reference point and

xi. This way, it is possible to assign absolute times, such as “noon” or “03:15 PM” to events.

Thus, if for example our time unit is a minute and our temporal reference point is noon, stating

that event x1 takes place at 03:15 PM can be expressed as I01=[195,195], which, being

equivalent to 195 ≤ x1 − x0 ≤ 195, implies that x1 = 195.

2.2.3 STPs and temporal plans

STPs can be used to model temporal plans. Such a temporal plan consists of a set of actions

together with a set of (temporal) action constraints. Action constraints might pertain to the start

and ending point of one action a, thereby constraining the time it might take to execute the

action, or might pertain to the start and ending points of two different actions.

When modelling a temporal plan as an STP, it suffices to take two time point variables for each

action a in the plan: one variable represents the start of the action, and the other represents its

end.

-13-


2.2.4 Graph representation of STPs

There are several ways to represent an STP as a (directed) graph. In each of these, the vertices

represent the time point variables (or events) and the edges represent the constraints between

them. The Simple Temporal Network (STN) is a directed graph in which each edge xi → xj

represents the constraint cij and is labelled with the interval I ij that corresponds to that constraint.

In a distance graph, each edge xi → xj is labelled with a weight w and represents the linear

inequality xj − xi ≤ w. The constraint aij ≤ xj − xi ≤ bij can be split into two inequalities aij ≤ xj − xi

(or alternatively xi − xj ≤ − aij) and xj − xi ≤ bij. This constraint is then represented by the edges xi

→ xj and xj → xi, labelled with bij and −aij, respectively.

Figure 2.1: Simple Temporal Network.

-14-


Figure 2.2: Distance graph.

Example 2.3 Alice's problem in Example 1 can be modelled as an STP as follows. There are

four time point variables X = {x0, …, x3}, where:

x0 = the temporal reference point,

x1 = Alice's arrival at the airport,

x2 = the moment check-in closes,

x3 = the aircraft's departure.

If the temporal reference point x0 refers to noon, then the following constraints C = {c0,3, c1,2,

c1,3, c2,3} exist between these time point variables:

c0,3 = [210,210],

c1,2 = [0, ∞],

c1,3 = [0,150],

c2,3 = [30,30].

Figure 2.1 shows the STN of this STP, and Figure 2.2 shows its distance graph.

-15-


Conversion from the distance graph to the STN is simple. Every pair of edges between two

variables is replaced by a single edge. The original label of the remaining edge serves as the

upper bound of the interval; the label of the edge that is removed from the distance graph

appears negated as lower bound of the interval. Conversion in the other direction is analogous.

Example 2.4 In the example distance graph of Figure 2.2, x1 → x3 is labelled with value 150

and x3 → x1 is labelled with value 0. So in the equivalent STN (Figure 2.1) both edges are

replaced with the single edge x1 → x3, labelled with the interval [0,150]. Alternatively, we could

have chosen for the edge x3 → x1, labelled with [−150,0]. It is important to note that these are

all equivalent representations of the same STP.

2.2.5 The d-graph

In a distance graph the (time) distance between two variables xi and xj is expressed if there is a

constraint cij between the variables in the STP. If xi and xj are connected via a series of

(directed) edges, we can compute an upper bound for the time distance between xi and xj by

taking the sum of the labels of these edges. Since there may exist several paths leading from xi

to xj in the distance graph, we are particularly interested in the lowest upper bound for the time

distance, also called the shortest path from xi to xj.

Figure 2.3: d-graph.

-16-


The d-graph is the directed graph representation of an STP where each edge xi → xj is labelled

by the length dij of the shortest path from xi to xj. The d graph is therefore a complete graph:

every pair of vertices is connected by an edge. The d-graph of our example problem is displayed

in Figure 2.3.

There is a well-known algorithm (see Algorithm A.2 in the Appendix) to efficiently compute

the d-graph from the distance graph: the former can be constructed from the latter by solving the

all-pairs-shortest-paths (APSP) problem, which is to find the shortest path between each pair of

vertices.

While the distance graph offers a convenient way to represent an STP, the d-graph is an

important tool to investigate consistency properties of an STP, as we will see in the next section.

2.3 Solving STPs

2.3.1 Solutions of an STP

A solution of an STP is an assignment xi = τi of values to all the time point variables xi ∈ X such

that all constraints cij ∈ C are satisfied. Usually, a solution is represented as a list of values (τ0,

…, τn). An STP is called consistent if at least one such solution exists.

The d-graph plays an important role in determining the consistency of an STP: it can easily be

deduced that an STP is consistent if and only if its d-graph does not have any negative cycles. If

there is any variable in the distance graph for which a path exists from itself, through some

other variables and back to itself, with negative length, the STP has no solutions; if no such

variable exists, the STP is consistent. This means that once the d-graph has been obtained a

quick test suffices to decide whether or not the STP has at least one solution.

The Appendix details methods for determining consistency of STPs.

2.3.2 Finding particular solutions

Once we know that an STP is consistent, we want to find an assignment that satisfies the

constraints. Fortunately, we can use the d-graph to obtain two special solutions in an easy way:

• the earliest start time solution EST = (0, −d1,0, … , −dn,0), which assigns to each variable

the earliest possible time, and

-17-


• the latest start time solution LST = (0, d0,1, …, d0,n), which assigns to each variable the

latest possible time.

These two solutions can be read off the d-graph immediately, by simply checking the labels of

the edges between x0 and every other vertex.

Example 2.5 In our example, EST = (0, 60, 180, 210). This solution corresponds to all edges

x0 ← xi in the d-graph of Figure 2.3. Similarly, LST = (0, 180, 180, 210). This corresponds to

all edges x0 → xi.

2.3.3 Finding other solutions: partial solutions and decomposability

Many constraint satisfaction problems are extremely sensitive to the order in which variables

are selected to assign values to in finding a solution. It might be the case that with a particular

variable ordering a solution can be found quite easily, while using another ordering of variables,

solutions can hardly be obtained. Fortunately, an STP can be made insensitive to the order in

which variables get values assigned to them. This desirable quality is called decomposability,

and to explain how it can be obtained, we first discuss the notion of partial solutions.

In a partial solution, time values have only been assigned to a subset of the time point variables.

We call such a partial solution locally consistent if all constraints between the variables

participating in the partial solution have been satisfied.

A network is decomposable if every locally consistent partial solution to a subset of its variables

can be extended to a globally consistent solution. This means that the order in which values are

assigned to the variables does not matter. While a distance graph of an STP is not always

decomposable, the d-graph always is.

-18-


Figure 2.4: This distance graph is not decomposable.

Example 2.6 The distance graph of Figure 2.2 is not decomposable. Suppose we have

assigned the values x1 = 0 and x2 = 200, as shown in Figure 2.4. This locally consistent partial

solution can never be extended to a globally consistent solution. In every globally consistent

solution, the value of x2 should be at most 150 larger than the value of x1, which can be

concluded from Figure 2.3.

Example 2.7 The d-graph in Figure 2.3, on the other hand, is decomposable. If x0 = 0, then x1

can be assigned any value between 60 and 180. This will always be consistent with the

assignments x2 = 180 and x3 = 210.

In a decomposable network, when assigning times to time point variables, only local

information is needed to guarantee a globally consistent solution. To any variables not

connected by a constraint, a value could then be assigned in parallel. An even stronger form of

independence than decomposability is offered by temporal decoupling, which can be seen as the

extension of decomposability to sets of variables. In a decoupled network several subnetworks

exist that can be solved completely independently of each other. Thus, values can be assigned to

variables in parallel for these entire subnetworks, while still guaranteeing a globally consistent

solution. Temporal decoupling will be discussed in more detail in Chapter 5.

-19-


2.3.4 Finding other solutions

Other solutions than the two special solutions already mentioned can be found by the STP-

solution algorithm detailed in Appendix A.4. This algorithm, using the decomposability

property, operates on the d-graph of the STP and assigns values to the variables one at a time, in

arbitrary order. The value assigned must be within the so-called time window of the variable;

this consists of all allowable time values. The time window is initially derived from the EST and

LST values that can be read off the d-graph and is updated whenever a value is assigned to a

variable. Time windows can only shrink during the execution of the algorithm: a value that is

initially forbidden will never become allowed. However, if the STP is consistent, no time

window will ever become empty and a solution can always be found.

2.4 Dealing with uncontrollable events: offline and online dispatching

2.4.1 Finding solutions offline

In the previous section we discussed some methods to solve an STP. Such a STP-solution

algorithm constructs a solution before the execution of the schedule begins. This solution can be

used as a precise specification of when each event should occur. An offline dispatching

algorithm for STPs involves creating a solution using this algorithm, ordering the events in the

solution in increasing time order, and dispatching the events when their specified time has been

reached.

2.4.2 Finding solutions online

When dealing with uncertainty, i.e., if there are uncontrollable events in the temporal plan, the

schedule can't be determined beforehand and has to be constructed during execution (online).

The times are then assigned to uncontrollable events as they are observed, and the plan is

adjusted accordingly. If an uncontrollable event occurs outside its time window, then no

solution can be found: at least one constraint has been violated.

Pollack and Tsamardinos [18] present an online dispatching algorithm, that creates such

solutions dynamically. This algorithm keeps track of whether variables are enabled and live. A

variable is enabled if all variables that are constrained to occur before it have already been

executed. A variable is live if the current time is within its time window. A controllable variable

can be dispatched as soon as it becomes both enabled and live. If a controllable event is

dispatched or an uncontrollable event occurs, the dispatch or observation time is propagated to

-20-


all undispatched variables, which may become enabled as a result. If an uncontrollable event

occurs while it is not enabled or not live, the algorithm breaks execution and takes domain

dependent action, since a constraint must have been violated. For an automatic system, an

example of such a “domain dependent action” could be informing a human operator.

In situations where a fast (real-time) response is needed, the online dispatching algorithm

described above may be too slow, since it updates the time windows of all remaining variables.

Pollack and Tsamardinos [18] describe an improved online dispatching algorithm, that only

updates the time windows of immediate neighbours. This works as long as the graph is

decomposable, which is the case for the d-graph. Applying this alternative algorithm to the d-

graph immediately, however, does not improve efficiency, since the d-graph is fully connected

and each variable has all others as its immediate neighbours, as the reader will recall. Therefore,

unneeded edges are removed from the d-graph before starting the algorithm; for details, see

Theorem 2 in the Appendix.

2.5 Summary

We have discussed the STP model as a temporal model that can be used for representation of

and reasoning with temporal problems. In this model, a temporal problem consists of a set of

time point variables and constraints between these variables.

An STP can be solved by first solving the familiar all-pairs-shortest-paths problem, resulting in

the d-graph representation. Consistency of the STP can be checked by inspecting the d-graph,

and particular solutions can be easily obtained from this graph representation. A d-graph is

decomposable, which means that a consistent solution can be found by assigning values to the

time point variables in any order.

A distinction is made between offline and online dispatching algorithms. Offline algorithms

create a plan before execution begins. Online algorithms create a plan on-the-fly, assigning

times to events as they occur.

In Air Traffic Management, one can differentiate between several planning phases: strategic,

pre-tactical and tactical. This chapter showed that the STP model, given its expressiveness and

fast solution algorithms, is well-suited to temporal planning in the strategic and pre-tactical

phases. Moreover, the online and offline dispatching extends its applicability to the tactical

flight phase as well, since this mechanism enables one to deal with uncontrollable events during

the execution of a plan.

One has to bear in mind the flip side of the coin, though: not all temporal problems can be

-21-


modelled as STPs. Indeed, as its name indicates, this formalism is only applicable to relatively

simple problems. As such, it can only be applied to an idealisation of the airport planning case.

Some extensions which allow for the representation of more complex problems are presented in

the next chapter.

-22-


3 STP extensions

STPs are rather limited in the kind of problems they can solve. Therefore the STP formalism has

been extended in several ways, to be able to solve more complicated problems than those the

formalism was designed for originally. These extensions include disjunctions of several

temporal intervals [23], preference values [12], resources with a capacity [3], conditional

execution of events [26], temporal uncertainty [17], and probability distributions to represent

expectations [25]. Figure 3.1 gives an overview of these extensions. The grey area in this figure

indicates the extensions that are discussed in this report, which are disjunctions, preferences and

resources.

Figure 3.1: An overview of STP and its extensions.

It is important to note that all the extensions discussed in this chapter are much harder to solve

than the STP, though (and because) they greatly increase the scope of problems that can be

expressed by them. In fact, these problems are so hard that it is in general infeasible to solve

them for large instances. What exactly constitutes a ‘large’ instance differs from case to case,

but practical problems usually fall in this category.

In the next chapter, we will go into more detail on strategies that deal with the first problem

extension discussed below: disjunctions.

-23-


3.1 Disjunctions

Very often there are several alternative options for solving a certain problem. To go to the

airport, for example, Alice could either go by car or by public transport. This element of choice

can be modelled with disjunctions.

The STP formalism can be extended by allowing the constraints to be disjunctions of temporal

inequalities, instead of just a single inequality. This has been described in the Temporal

Constraint Satisfaction Problem model in the original paper by Dechter et al. [5]. Stergiou and

Koubarakis [23] described an even broader class of problems in the Deciding Disjunctions of

Temporal Constraints problem, which has also been referred to as Disjunctive Temporal

Problem.

3.1.1 The Temporal Constraint Satisfaction Problem

In a Temporal Constraint Satisfaction Problem (TCSP), a constraint between two time points

can be expressed as a disjunction of several intervals:

xj − xi ∈ I ij1 ∪ ⋯ ∪ I ijn = [aij1, bij1] ∪ ⋯ ∪ [aijn, bijn]

This allows the time difference between the two variables to assume a value from any of the

intervals, instead of from just a single interval. The network representation of the TCSP is quite

similar to the STN; the only difference is that edges are not labelled by a single interval, but by

a union of intervals.

Example 3.1 Alice's mother calls from the supermarket to say that she is delayed and will not

be able to be home in time. Now Alice either has to drive to the airport herself (25–35 minutes),

or she can go by public transport (45–55 minutes). The constraint c4,1 between x4 (the moment

she leaves her house) and x1 (the moment she arrives at the airport) is thus changed to c4,1 = I ij1

∪ Iij2 = [25,35] ∪ [45,55].

The network representation for this situation is depicted in Figure 3.2.

-24-


Figure 3.2: The network representation of the problem in example 1.

3.1.2 The Disjunctive Temporal Problem

In a Disjunctive Temporal Problem (DTP), a different approach is taken: here, every constraint

is a disjunction of two or more inequalities involving two variables:

(xj1 − xi1) ≤ ci1j1 ∧ ⋯ ∧ (xjn − xin) ≤ cinjn

The difference with the TCSP is that more than two single variables may participate in one DTP

constraint. Conversion from the TCSP to the DTP is therefore much more straightforward than

vice versa, and for the same reason, there is no simple network representation of the DTP:

edges, which join two variables, are now no longer sufficient to represent DTP constraints.

3.2 Preferences

Sometimes certain solutions are more preferable than others. For example, an airline may

request that passengers be at the airport at least two hours before their flight departs. Usually

this does not mean that a passenger cannot board anymore if he arrives only one hour in

advance, but he should not plan to arrive that late if it is possible to arrive earlier.

To express that certain values are more preferable than others, Khatib, Morris, Morris and Rossi

[12] have added preferences to STPs. They achieved this by adding to each constraint a

preference function, that associates a preference value with every temporal value in the interval

identified by that constraint. This preference value is a measure of the desirability of that

temporal value. The goal now is to generate solutions to these problems that are preferred

overall, which means that they simultaneously meet all local preference criteria as well as

-25-


possible.

In a Simple Temporal Problem with Preferences (STPP) the hard constraints cij = I ij are replaced

by soft constraints cij = <I ij, fij>, where fij : x ∈ I ij → [0,1], where [0,1] is the range of allowed

preference values. A solution to an STPP is a complete assignment of times to variables, that

satisfies all temporal distance constraints. Each solution has an overall preference value,

obtained by combining the local preference values found in the constraints. The optimal

solutions of an STPP are those solutions that have the best overall preference value.

There are many different methods for combining local preference values into an overall

preference value, and which method is best varies between application areas and the goal one is

trying to achieve. A straightforward option is taking the average of all local preference values,

but one can also take the overall preference value to be the minimum over all local preference

values; this ensures that this minimum is lifted as high as possible, or put informally, the

`unhappiest' constraint is made as `happy' as possible.

Example 3.2 The airline requests that passengers be at the airport at least two hours before

their flight departs. However, passengers that arrive later will still be able to check in until

check-in closes. This can be expressed by adding the following preference function to constraint

c1,3:

f1,3(a) = {0 a ∈ [0,30]

0.5 a ∈ [30,120]

1 a ∈ [120,150]

This function is shown in Figure 3.3 below.

-26-


Figure 3.3: Preference function f1,3(x).

Though we noted in the introduction to this chapter that the problem extensions discussed are

very hard, for some subclasses of STPPs, it can be proven that their difficulty is comparable to

that of the STP. The subclass discussed here is the STPP with semi-convex preference functions.

A formal definition of a semi-convex function is given in the Appendix, definition 7.

Informally, a preference function is semi-convex if and only if, when walking through the

values from low to high, the preference value is non-decreasing up to a certain point, after

which it is non-increasing. Functions that are entirely non-decreasing or non-increasing are also

semi-convex. No value in the middle of any interval may be less preferred than both values at

the edges of the interval. Some examples of semi-convex functions are given in Figure 3.4.

-27-


Figure 3.4: Examples of semi-convex functions (a)-(f) and non-semi-convex functions (g)-(i).

An STPP with semi-convex preference functions can be solved by searching the space of

projected STPs. Here, the projected STPs are defined by the preference functions associated

with each STPP constraint. For every preference level p, the projected STP at level p can be

obtained by restricting all constraints to their (sub)interval for which the preference value is at

least p. If all preference functions are semi-convex, then every STPP constraint will map to at

most one STP constraint, thus resulting in an STP.

An optimal solution can be found by searching for the maximum p such that there exists a

consistent projected STP at level p. If there is a finite set of k preference levels, this search takes

at most about k times as long as solving such a single STP does.

Another subclass of the STPP for which solving is feasible is discussed in the Appendix.

3.3 Resources

Many planning problems involve assigning resources to tasks. For example at an airport the

aircraft have to use the runway for landing and takeoff. In an STP this can be modelled as a

number of activities that should not overlap. Often, however, the use of a resource is not

restricted to one single activity, but it may serve up to a certain number of activities at the same

time.

Cesta, Oddi and Smith [3] have added resources with a capacity to STPs. Whereas in regular

STPs every resource can only serve one activity at any point in time, in a Multiple-Capacitated

-28-


Metric Scheduling Problem (MCM-SP) resources have a capacity to serve multiple activities

simultaneously.

In an MCM-SP there is a set of resources R = {r1, ..., rm}, that can be used to perform a set of

jobs over time. A job consists of a sequence of activities. Execution of each activity ai is subject

to the following constraints: resource availability, processing time constraints (between the start

and the end of the activity), separation constraints (between two successive activities of the

same job) and job release and due dates. A resource r j has a resource capacity rcj to process at

most rcj activities at the same time (with rcj ≥ 1). A solution to an MCM-SP is any temporally

consistent assignment of start and end times, that does not violate the resource capacity

constraints. Thus, compared to an STP, an MCM-SP explicitly deals with the notion of activities

ai, that have a start time sai and end time eai and that may require capacity of certain resources,

instead of with the separate time points that may implicitly be regarded as start and end times of

activities.

Temporal information is represented by a distance graph that corresponds directly to the

distance graph of an STP. With regard to resource information, the required capacity or resource

demand of a resource r j by an activity ak is denoted as rdak,j, and the set of activities ak that

demand resource r j is denoted as Aj = {ak | rdak,j ≠ 0}. For each resource r j a demand profile

rdj(t) can be defined, that represents the total capacity requirements of ak ∈ Aj at any instant of

time. Then for r j the resource capacity constraint requires that rdj(t) ≤ rcj for all t.

Example 3.3 Alice waits at the gate for boarding to start. The aircraft she will board is

currently being fuelled by a ground handling crew.

Different aircraft types may have different ground handling crew needs; for example, the

aircraft Alice will soon board requires two ground handling crew members for refuelling,

whereas smaller aircraft may require only one. Other activities, for instance cleaning, cargo

loading or boarding, may likewise differ in their personnel requirements.

The airport's refuelling crew consists of 10 members, and may thus be modelled as a resource r1

with resource capacity rc1 = 10. The servicing by the several ground handling services of an

aircraft may be seen as a job, and this job involves the activity of refuelling; other activities

involved are cleaning and cargo loading.

If there are three more aircraft of the same type as Alice's at the airport, and two smaller

aircraft that require just a single refuelling operator, the refuelling activities can be modelled

with the symbols a1 through a4 for the larger aircraft, and a5 and a6 for the smaller ones. The

-29-


resource demands then are rda1,1=rda2,1=rda3,1=rda4,1=2 and rda5,1=rda6,1=1. The reader can

verify that the demand profile rd1=10, which is equal to the resource capacity, so all aircraft

can be refuelled at the same time.

If one of the small aircraft were of the large variety, or another small aircraft had to be

refuelled, this would result in rd1=11, which would have exceeded the resource capacity. In this

case, Alice's aircraft may have had to wait for its refuelling, further postponing the boarding of

her flight.

-30-


4 Solving extended STPs

In this chapter, we will discuss how the STP extended with disjunctions (the TCSP and the

DTP) can be solved. We will discuss two methods: the “conventional” method and local search.

While solving the STP is not a hard problem, the same cannot be said for the TCSP and the

DTP. These can be proved to belong to a class of problems, called NP-hard, for which no

efficient general solution technique is known and for which it is conjectured that such

techniques do not exist. The reader may have heard of the Travelling Salesman Problem, which

also belongs to this class.

For more theoretical details on the complexity of the problems, we refer the reader to the paper

by Dechter et al. [5]; the implication for this chapter is that we have to look for techniques that

perform well for the majority of the cases, if not in general.

4.1 The conventional method

A temporal problem with disjunctions can be brought back to the form of the STP by picking a

single interval for each constraint (in the case of the TCSP) or picking a single disjunct for each

constraint (in the case of the DTP). Such a set of choices is called a labelling. If an STP

contructed in this way has a solution, this is also a solution for the TCSP or DTP. If it does not,

the search continues. A single solution might be found rather quickly (in the first try, for

example, if we are very lucky), but for finding all solutions or concluding that no solutions

exist, all possible labellings have to be checked.

A naive algorithm that follows this approach for the case of the TCSP is detailed in figure 4.1.

The basic case is if the problem is an STP, i.e., there are no constrains with more than one

interval. In this case, the STP solving algorithm is invoked (in step 10) and the solution is

returned.

If there are constraints with more than one interval, the algorithm enumerates all labels for this

constraint (steps 4 and 5). A new set of constraints C' is constructed (in step 6) which is

equivalent to C except for the just-labelled constraint. The solving algorithm recursively calls

itself in step 7 for this set of constraints; the solutions are added to S. When all labellings have

been enumerated, S is returned.

-31-


Solve-TCSP(X,C)

Input: A TCSP with variables X and constraints C.

1. S := ∅ (the set of solutions)

2. if C has constraints with more than one interval

3. c := the first such constraint

4. for i := 1 to nc (the number of intervals in c)

5. c' := the ith interval from c

6. C' := (C − {c}) ∪ {c'}

7. S := S ∪ Solve-TCSP(X,C')

8. return S

9. else

10. return Solve-STP(X,C) (the problem is an STP)

Figure 4.1: Naive algorithm for solving TCSPs.

If we denote the amount of options offered by constraint cj by nj, the total number of STPs that

can be generated and have to be checked by this algorithm is n1 · n2 · ⋯ · n|C|, where |C| equals

the amount of constraints in the problem. If every constraint offers just two options, this number

is equal to 2|C| and is thus exponential. Adding just one extra constraint will double the amount

of options and hence the expected runtime, which will become very large very quickly. This

gives a rough idea of why the problem under scrutiny is so hard.

Of course, many improvements over the naive method presented exist. For example, when

labelling a constraint, it is possible to do a check that all remaining constraints still have some

options open; if a labelling blocks all options for some future constraint, then this labelling is

clearly no good. When encountering inconsistencies, the algorithm might conclude that this

inconsistency has been introduced not when labelling the last constraint, but by some labelling

in the more distant past, and it is of no use to try changing any of the labellings done in

between. These techniques are called forward checking and backjumping respectively and are

detailed by Stergiou and Koubarakis [23].

Xu and Choueiry [29] combine a variety of techniques, which include the ∆STP algorithm,

exploiting the topology of the network, and a filtering algorithm, the latter of which is run

before the actual solving process.

Notwithstanding all these enhancements, the search space will still be exponential in the worst

-32-


case, which is just too big for these complete algorithms to run with acceptable efficiency.

4.2 Introducing local search

A different method for finding solutions to temporal planning problems, and indeed for general

constraint satisfaction problems, is the method of local search, which we will introduce in this

section.

The fundamental idea of local search is to start by assigning a (random) value to every variable,

evaluate the state of the system (see which constraints are violated) and look for neighbouring

states that improve the state of the system. Neighbouring states are those states which differ

from the current state only by the value of a single variable. This so-called hill-climbing

technique hopes to wind up in a state in which no constraints are violated, i.e. a solution.

Of course, this simple approach will not suffice. It is not hard to imagine a situation in which

the current state is not a solution, which means that not all constraints are satisfied, yet there

exist no neighbouring states that satisfy more constraints. Such a state is called a local optimum.

The variations of local search, described in the next section, differ mainly in the way they deal

with these local optima.

Even with the most advanced technique for handling local optima, we must emphasise that it is

an intrinsic property of local search that solutions, if present, may not be found. The algorithm

can try to deal with this by using random restarts: if no solutions have been found after a certain

number of steps, or if the highest point reached is not improved upon for a certain number of

steps, the algorithm starts anew with a clean slate, from a random initial state. But even this

technique, however effective, offers no guarantees.

Another important difference from complete algorithms is that a local search algorithm cannot

conclude that a problem has no solutions at all; it will just keep on running. The strength of

local search lies in quickly closing in on a solution. The challenge for the programmer is to

design an algorithm for which the techniques it employs are chosen such that it is tailored to the

problem that is to be solved.

4.3 Local search techniques

One of the simplest measures one can take to deal with local optima is plateau search [21].

When the algorithm finds it can no longer take a step that improves the current state, it takes a

non-improving `sideways' step instead: a step that, while not decreasing the amount of

constraints violated, doesn't increase it either. The algorithm explores the `plateau', so to speak,

-33-


until it encounters a peak and it can start climbing again. This straightforward strategy can

significantly improve the performance of an algorithm.

Another reasonably simple technique is called tabu search [7][8]. This involves keeping a list of

the last few states the algorithm has been in and disallowing a change of a variable that would

revert to such a state. An analogy can be made with learning: instead of seeing every state as

completely new (akin to goldfish, as the well-known myth would have it), the algorithm

recognises places it has been in before. A parameter for tabu search is the amount of previous

states that should be remembered. Increasing this parameter will improve the performance of the

algorithm, at the cost of needing more memory for the remembered states. The algorithm cannot

hope to remember all states it encounters on its way to a solution, since this number may well be

exponential.

More involved is the technique of constraint weighting, also called the breakout method

[16][19]. Every constraint is given a weight, initially equal to 1. The weight indicates how

`important' it is that the associated constraint be satisfied; at first, all constraints have the same

importance. When a local optimum is encountered, which as the reader will recall means that

there are no neighbouring states which are considered `better', those constraints which are

violated have their weight incremented; they are now deemed more important than their

satisfied counterparts. This means that now the current state is no longer a local optimum and

the algorithm can continue. If we return to our analogy of plateaus and mountains, altering the

weights of constraints would correspond to raising a hill where the landscape was previously

flat, or even valley-like. So, instead of changing its own position in the search space, the

breakout algorithm changes the aspect of the search space itself.

An entirely different approach is a so-called random walk strategy [20]. In this case, a random

violated constraint is selected, after which there are two possibilities:

• with probability p: randomly alter one of the variables appearing in the constraint,

without regard for the consequences;

• with probability 1−p: pick a variable participating in the constraint and a value for that

variable, such that the constraint under scrutiny is satisfied and the number of new

constraints that become violated is minimised.

The reader should note that in the case of the TCSP, only two variables will appear in each

constraint, so the choice for a variable appearing in the constraint is always between just two

options. In the case of the DTP, the number of featured variables may be higher, so the choice,

especially in the second case described above, is more complex. The parameter p can be varied

between 0 and 1 and needs to be fine-tuned to the characteristics of the problem that is being

-34-


solved. The random walk strategy has shown to be highly effective on many problem domains,

including temporal planning.

The last technique we will discuss is that of simulated annealing [13][11], inspired by the

metallurgical heat treatment of the same name. In this method, a random variable and a value

are picked and then the value δ is computed: the difference in the amount of constraints satisfied

if the change were made. If δ is zero or positive, i.e. the amount of violated constraints will not

increase, the change is made unconditionally; otherwise, the change is made with probability

eδ/T, where T is a parameter called the temperature. This can be kept constant while running the

algorithm, or can be gradually decreased from some high value to near zero.

4.4 Local search in the temporal domain

Though the technique of local search has seen wide application for quite diverse types of

problems, not much research has yet been conducted on applying it to the TCSP or the DTP. To

understand why this is, we must first explain that there are two ways of looking at temporal

problems from the perspective of local search. This hinges on the definition of a state, its

evaluation and its neighbours.

The most straightforward approach for dealing with temporal problems is to see an instatiation

of every temporal variable with a value as a state. Evaluation of such states is likewise

straightforward: simply count how many constraints have been violated. Obviously, the lower

this number, the better the state is considered to be.

The usual definition of the neighbours of a state is “all states that differ from the current state

only by the value of a single variable”. Again, this is straightforward, but it seems to be

problematic: there is a very large (if not infinite) amount of time values we can assign to a

variable. This is just for a single variable; if there are N variables, the amount of states that

neighbour the current state would at first glance be proportional to N times the amount for a

single variable. When a local search algorithm makes a step from one state to a neighbour,

searching through all these candidates would clearly be very detrimental to the algorithm's

performance.

To avoid this exuberant neighbourhood, a different path can be taken. Because there exist

efficient algorithms for solving the STP, and a TCSP or DTP where all constraints have been

labelled is equivalent to an STP, we can also regard a labelling of every constraint as a state in

the local search algorithm. A state then corresponds to an STP and a check of the STP for

consistency will tell whether the state is a solution or not. Because an STP is a constraint

satisfaction problem (CSP), the entire problem is often referred to in the literature as a meta-

-35-


CSP when this approach is used [15][23]. This meta-CSP approach directly corresponds to the

method employed by complete algorithms described in section 4.1.

The set of neighbouring states is obtained by enumerating all possible labellings that differ only

in the label of a single constraint. The size of this set is then equal to the total number of labels

in the problem (minus one, for the current state) and is far smaller than the neighbourhood in the

previously described strategy; therefore, it is much more manageable.

Evaluation of a state, i.e. determining how close it is to a solution, is problematic when using

this approach, however. If an STP is determined to be inconsistent, this yields no further

information about the quality of the chosen labelling, nor about which label should be changed.

Both of these pieces of information are of paramount importance for the performance of the

local search algorithm; without them, the algorithm is completely in the dark, blundering about

aimlessly. Even apart from these, another problem is that the algorithm for determining

consistency of an STP, though efficient, certainly doesn't yield an answer instantaneously.

Consulting it for every neighbouring state in every step of local search will noticeably take its

toll on performance indeed. Because of these problems, we now focus our attention on the first

strategy again.

Looking back, we see that the only problem with the earlier approach was the enormous size of

the set of neighbours. But need we really investigate all possible values for a variable? It turns

out that this is not the case: the algorithm only has to consider those values which mark the

border between a constraint being violated or not, barely satisfying it. With this criterium, the

amount of values to consider for a variable adds up to at most twice the number of intervals (in

the case of the TCSP) or disjuncts (in the case of the DTP) in which a variable participates,

which makes the size of the total neighbourhood at most double the size it was for the meta-

CSP, which is more than acceptable.

The considerations described in this section were detailed in 2005 by Moffitt and Pollack [15].

They built a solver (named Localitis) which employed a random walk strategy augmented with

tabu search and tested it on randomly generated, over-constrained instances of the DTP; since

they were over-constrained, they were known to have no solutions, and the goal was to

maximise the amount of satisfied constraints. Their results are promising: Localitis performs

better on this domain than the best-performing complete algorithm by the same authors.

Localitis is as yet the only local search algorithm developed for the TCSP or DTP. In 2002,

Thornton, Beaumont, Sattar and Maher [24] described a local search algorithm for another class

-36-


of temporal reasoning problems. Their algorithm, that likewise did not take the route of the

meta-CSP, also showed promise for this approach.

4.5 Conclusion

In this chapter, we discussed techniques for solving the STP extended with disjunctions; to wit,

the TCSP and the DTP. We have seen that these problems are far harder to solve than the STP,

as they incur a worst-case time complexity that is exponential in the number of variables.

Conventional solving methods work by iterating over labellings and determining whether the

STPs induced by each labelling are consistent or not. The naive algorithm is intractable and this

is the worst-case behaviour for all available complete algorithms, though significant

improvements can be made in the method of operation.

Having noted this, we next introduced the method of local search. This technique has in a

variety of application areas shown to perform well for problems that are too big for complete

methods to tackle. Its strength lies in closing in on a solution quickly; its weakness is that it can

never conclude that a problem has no solutions and may fail to find a solution even if it is

present.

We listed a variety of techniques that local search algorithms can use to deal with local optima.

These served mostly to give the reader an idea of the extent of the field of local search. One of

the challenges for the designer of an algorithm is to pick techniques and parameters tailored to

the problem that is to be solved.

Finally, we noted that for temporal problems, two approaches exist. In the most straightforward

approach, an instantiation of variables is regarded as a state; in the meta-CSP approach, which

directly corresponds to the conventional solving method, a state corresponds to a labelling of all

constraints. We saw that the meta-CSP approach was ill-suited to local search and showed

how—in the direct approach—the state neighbourhood could be reduced to a manageable size

by considering only specific values for each variable. Two existing algorithms employ the direct

approach with a reduced neighbourhood and have shown promising results.

-37-


5 The Temporal Decoupling Problem

In many applications a temporal plan consists of actions (tasks) that are to be executed by a

group of actors. For example, in planning ground handling services at an airport, actions

occurring in the ground handling plan have to be performed by actors including the fuelling

operator, the cargo loading operator, the cleaning operator, the catering operator and the

passenger boarding operator. Since usually actions in a plan that is to be executed by different

actors are temporally dependent, these actors need to co-ordinate the execution of these tasks.

At the same time, as they usually belong to independent organisations with their own business

policies, they may want to operate as independently as possible.

In situations like this, it is desirable to be able to split a temporal network representing the

temporal plan into independent subnetworks, such that each of these can concurrently be solved

by a different actor. While each of the solutions found by the independent actors may be

adequate to solve the subproblems represented by the subnetworks, the question of course is

how to ensure that these independently constructed solutions jointly constitute a solution for the

total problem.

This problem is known as the Temporal Decoupling Problem (TDP) and has been investigated

for problems with simple qualitative ordering constraints [2], for ordering constraints and

synchronisation constraints [22] and for STPs [9][10]. In this chapter, we focus on the latter

problem, which has been researched by Hunsberger. The problem he investigated can easily be

stated:

How can a Simple Temporal Problem be split into subproblems that can be solved

independently?

Hunsberger's solution comes down to finding a suitable set of additional constraints between the

subproblems such that a decoupling can be achieved.

In this chapter, only the case of splitting a network into two independent subnetworks will be

discussed. The case of an arbitrary number of decoupled subnetworks is analogous. We also

should remark that for the extensions we discussed in chapter 4, no suitable decoupling methods

have yet been found. The problem can however be stated similarly: how to split the problem

into several parts that can then be solved concurrently by multiple actors, while ensuring that

the solutions they reach are mutually consistent?

-38-


For an example (ground handling) application of the Temporal Decoupling theory discussed in

this chapter, the reader is referred to Deliverable D2 [6], Section 4.

5.1 What is the Temporal Decoupling Problem?

Before we discuss the details of the Temporal Decoupling Problem (TDP), we first introduce

the terms z-partition and temporal decoupling.

A z-partition (Definition 8) is a split of the set of time-point variables into two parts, which only

have the temporal reference point z = x0 in common. An example of a z-partition is given in

Figure 5.1.

Figure 5.1: A z-partition.

A temporal decoupling of an STP S (Definition 9) splits it into two sub-STPs SX and SY which

have the following properties:

• SX and SY are consistent;

• The variables of SX and SY form a z-partition of the variables of S;

• Merging any solutions for SX and SY necessarily yields a solution for S. (Mergeable Solutions Property)

The Temporal Decoupling Problem (Definition 10), then, is to find a temporal decoupling for

an STP with a given z-partition.

-39-


If the original STP is inconsistent, no temporal decoupling can exist: either no consistent

subproblems can be found, or if these can be found, merging their solutions would never yield a

solution for the original STP (otherwise it would have been consistent in the first place).

The difficult part of finding a temporal decoupling, of course, is how to ensure that the

Mergeable Solutions Property is satisfied. As can be seen above in the list of properties for the

sub-STPs, no new variables are introduced, so the only available way for achieving a temporal

decoupling is by modifying the constraints in the original problem. The idea is to modify the

constraints in the subproblems in such a way that a solution for one of the subproblems does not

invalidate any solution found for the other problem. Before we explain how this may be done,

let us first continue our running example.

Example 5.1 Alice has asked her mother to bring her to the airport by car. The moment Alice

has to leave her house is depicted in Figure 5.2 by time point variable x4. Driving to the airport

will take 25 to 35 minutes so c4,1 = [25,35]. Alice's mother agrees to bring her daughter, but she

wants to go to the supermarket first. She will need one to two hours to buy all her groceries and

wants to be back home at least 15 minutes before she has to leave again. This is depicted by

time point variables x5 to x7. The constraint c4,7 = [0,0] because Alice and her mother have to

go to the airport at the same time.

Figure 5.2: A z-partition of the example.

-40-


The figure shows the z-partition of this problem. Alice's mother will make a plan for the upper

part of the graph, whilst Alice will make a plan for the lower part of the graph. The question is:

how can Alice and her mother be sure that their plans will be compatible?

5.2 Solving TDPs

Hunsberger's algorithm for solving TDPs is quite involved, although the basic idea behind the

algorithm is not very hard to understand. We present this main idea and refer to the Appendix

for the technical details.

Suppose that we have split S into a z-partition { SX, SY }. The only constraints that could

invalidate a solution for SX if a solution for SY has been found, or vice-versa, are constraints

between a variable x in SX and a variable y in SY, with both of these variables unequal to the

temporal reference point z. Such a constraint, represented by an edge in the distance graph

representation, is called an xy-edge (Definition 11).

These xy-edges can be removed (and the corresponding constraint can be ignored) if the two

constraints xz and zy (which form a path from x to y through the temporal reference point z)

imply the constraint xy, i.e. if all values for x and y that satisfy both xz and zy also satisfy xy. In

that case, xy is said to be dominated by a path through zero and can be removed.

The idea behind the algorithm now is to tighten the constraints xz and yz corresponding to each

xy-edge in such a way that the latter becomes superfluous and can be removed from S.

`Tightening' a constraint means making it more strict, in the sense that it allows less solutions;

see also Definition 2 in the Appendix. The final result is then an STP S' which no longer

contains any xy-edges and has the property that the solutions obtained from SX and SY always

can be merged into a total solution; this means that SX and SY decouple the problem and the

Temporal Decoupling Problem has been solved for S.

However, there is a price to be paid: in general, not every solution of the original system is a

solution of the decoupled system. The most obvious reason for this is that constraints have been

tightened, which of course invalidates some solutions. A challenge for the decoupling algorithm

is to keep as many solutions as possible available, by applying just the right amount of

tightening.

Another reason for the reduced amount of solutions is that when tightening the pair of

constraints xz and zy, the total amount by which they have to be tightened is fixed, but the way

this amount is divided over the two constraints is variable. Here, a choice has to be made by the

algorithm, and it might turn out later that the choice made has rendered one of the subproblems

-41-


inconsistent, while the other has some slack left. A solution may then be found by trial and error

over a number of iterations.

Figure 5.3: The decoupled network.

Example 5.2 To keep their plans compatible, Alice and her mother have to agree on an exact

time for leaving home and going to the airport: as can be seen in Figure 5.2 the only xy-edge in

their case is the constraint c4,7, i.e. the edge between x4 and x7. The constraints to be tightened

so that c4,7 can be removed are c4,0 and c0,7.

In Figure 5.2, c4,0 and c0,7 are not displayed. Such inexistent constraints allow the difference

between the variables involved to assume any value and are thus implicitly equivalent to the

constraint [−∞,∞]. The original constraint c4,7 only allows x4 and x7 to occur at the same

moment. Any further tightening would yield inconsistency and is thus impossible.

Looking back at Figure 2.3, we can see that the distance from variable x1 to the temporal

reference point x0 is between 60 and 180 minutes. Since it takes between 25 and 35 minutes to

reach the airport, the distance between x4 and x0 lies between 25 minutes (the earliest departure

time, corresponding to 12:25 PM) and 155 minutes (the very latest, at 02:35 PM).

Alice and her mother can now agree upon any time in this interval for their departure to the

airport. They decide to leave at 01:15 PM, which translates into tightening c4,0 to [−75,−75] for

Alice and tightening c0,7 to [75,75] for her mother. The decoupled network is displayed in

Figure 5.3.

-42-


It can be seen that this decoupling drastically reduces the amount of solutions, even though

translating constraint c4,7 did not require any tightening: any scenario in which Alice's mother

returns from shopping between 01:00 PM and 02:20 PM would still have a solution in the

original problem, whereas after decoupling, this yields an inconsistency.

5.3 Extensions

The basic Temporal Decoupling Problem as has been discussed above can be extended upon in

various ways, to broaden its application area.

As has already been mentioned, it is preferable not to tighten constraints too much, since this

might invalidate solutions. A minimal temporal decoupling of an STN S (Definition 13) is a

decoupling with the property that any non-trivial weakening of the constraints in the decoupled

subnetworks would necessarily cause them to no longer decouple S. In other words, a minimal

temporal decoupling is the best we can get: a decoupling, guaranteeing that every partition can

still be merged into a total solution, but with a minimum reduction of potential solutions.

The basic TDP algorithm as described in the Appendix may result in a non-minimal temporal

decoupling, which means that the network will needlessly be restrained.

Example 5.3 Figure 5.4 shows an example in which the basic TDP algorithm results in a non-

minimal temporal decoupling. The z-partition in this case is between {z, x1, x2} and {z, y}. First

the constraint cx1z is tightened, to translate the xy-edge x1 → y. Likewise the constraint czy is

tightened, to translate the xy-edge x2 → y. This results in a graph in which the value for x1 → y

could be weakened again without disturbing the decoupling. Hence this decoupling is not

minimal.

-43-


Figure 5.4: The basic TDP algorithm may result in a non-minimal temporal decoupling.

Hunsberger has developed an Iterative Weakening Algorithm that constructs, given some

arbitrary decoupling, a minimal decoupling by iteratively weakening constraints inside

subnetworks.

In the Allocative Temporal Decoupling Problem, the partition of the network is only partially

specified. This means that some of the time points are already assigned to a specific agent, but

others still have to be divided among the agents. The question is how to divide the time points

that have not been allocated yet, and find a temporal decoupling, such that some quality metric

(e.g., flexibility) is maximised.

In the Relative Temporal Decoupling Problem, only a part of the network is fully decoupled. In

such problems there is a set of time points variables TW that is not decoupled from the rest of the

network. The agents are allowed to work completely independent of each other as far as this

concerns the time points of the decoupled subnetworks. At the same time they still have to co-

ordinate their tasks with agents controlling the time points in TW.

-44-


5.4 Summary

Hunsberger [9][10] has investigated temporal decoupling of STPs. With this technique, the

problem can be split into independently solvable subproblems, that require no further

communication between agents. This approach is especially interesting for very large problems,

which might take too long to be solved when handled wholesale.

A disadvantage of temporal decoupling is that some solutions may be lost. This downside of

decoupling, which can be regarded as the price of independence of the agents, may require

renegotiation when an original temporal decoupling leads to an inconsistency in one of the

subnetworks.

We must stress once more that decoupling has so far only been researched for the STP. The

notion of decoupling is also valid for the extensions of the STP that were described in Chapter

3, but no methods have yet been found that achieve such a decoupling for those problem

domains.

-45-


6 Conclusions

This report described the STP formalism and the Temporal Decoupling Problem. It has given an

overview of research done on temporal networks, its extensions, methods for solving one of the

extensions, and temporal decoupling. This chapter summarises these topics, and outlines a

direction for future research in the course of the CAED project.

6.1 Summary

The Simple Temporal Problem formalism has proven to be very useful for the representation of

and reasoning with temporal problems. After its introduction in 1991, it has inspired many

researchers to model temporal planning problems in a variety of practical domains. The

formalism has its limitations, however, in the kind of problems it can solve. For this reason, it

has been extended in several ways.

Much research has been done to find more efficient ways for solving the basic STP. In this

manner, not only can a larger class of problems be solved within a fixed time limit; faster

algorithms can also be important for solving problems that allow disjunctions of temporal

intervals (discussed below), since some of the underlying algorithms rely on the fast and

frequent application of the original STP solving methods.

Extensions of the STP formalism are directed towards modelling more complicated problem

domains. Such extensions are crucial for modelling real world problems, as the expressiveness

of the STP formalism itself is quite limited. This report has described disjunctions, preference

functions and resource allocation as possible extensions.

Disjunctions, the first extension upon the STP formalism we discussed, allow constraints to be a

union of several temporal intervals instead of just one interval (in the case of the TCSP), or

offer the choice which of a set of temporal inequalities should hold (in the case of the DTP).

The resulting model permits temporal choices (e.g., a flight may take either 50-60 or 90-110

minutes, depending on weather conditions) to be included in the STP framework. The second

extension we discussed added soft constraints to STPs, by which means the network can be

extended to include preference values. In this manner, not only hard constraints but also the

preferences of actors for events to occur within a certain time frame can be modelled. Finally

we discussed the allocation of shared resources to tasks as an extension to the original STP

framework. This allows one to express varying demand profiles for different tasks, and as such

adds an extra dimension to the problems, perpendicular to that of temporal planning.

-46-


Solution techniques for the TCSP and DTP extensions, targeting much harder problems than the

STP, were discussed. The standard method of solving repeatedly makes a choice for each

constraint and then solves the resulting STP. We noted that solving in the general case is

infeasible for problems of practical size, however intelligent the algorithm operates. The

methodology of local search was then discussed as a technique that often yields a solution

quickly, but may fail to come up with an answer at all.

Finally, this report addressed temporal decoupling. This is a very useful technique when

multiple agents have to coordinate their tasks, but still want to work independently of one

another as much as possible. Moreover, decoupling may allow very large problems to be split

up into smaller subproblems for shorter execution times in the problem solving phase. In this

document, temporal decoupling was described as a means to divide an STP into a set of

independent subnetworks. These subnetworks can be solved locally and in parallel, requiring no

further coordination between actors.

6.2 Future Research

This report aimed to provide a theoretical basis for the construction of an extreme decoupling

model in the CAED project. Central to this project is a new approach towards planning,

allowing different actors in a domain to develop their planning independently of one another as

much as possible. To this end, temporal decoupling was introduced as a means to deduct local

planning representations from the overall planning domain. The Simple Temporal Problem

framework has been presented as the formalism to represent the planning problem itself. Also, a

wide variety of extensions to this framework have been discussed to increase its expressiveness

and applicability.

Given these theoretical building blocks, the next step will be to apply theory to practice. In

Deliverable D2 [6], developed in parallel with this document, a first step has been made in this

direction. In that document, the turnaround process at an airport has been described as the

application domain for extreme decoupling. In the next work package of the CAED project,

these steps will be followed towards the development of a more mature decoupling model of

this example application domain.

Apart from difficulties in applying theory to practice, also some theoretical problems still need

to be solved. Most importantly, Hunsberger's decoupling algorithm is only suitable for regular

STPs. At this moment, not much research has been conducted yet to develop new decoupling

algorithms for dynamic STPs—where constraints can be added and deleted—and extended

STPs, in particular for dealing with disjunctions. Since distributed solution methods are

-47-


essential for solving large and complicated planning problems such as the turnaround, we will

certainly consider these to be part of future research.

-48-


7 References

[1] James F. Allen. Towards a general theory of action and time. Artif. Intell., 23(2):123–154,

1984.

[2] P.C. Buzing, A.W. ter Mors, J.M. Valk, and C. Witteveen. Coordinating self-interested

planning agents. Autonomous Agents and Multi-Agent Systems, 12(2):199–218, February

2006.

[3] A. Cesta, A. Oddi, and S.F. Smith. Profile based algorithms to solve multiple capacitated

metric scheduling problems. In Proceedings of the 4th International Conference on

Artificial Intelligence Planning Systems, AIPS-98, pages 214–223, 1998.

[4] Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest. Introduction to

Algorithms. The MIT Press / McGraw-Hill Book Company, 1990.

[5] Rina Dechter, Itay Meiri, and Judea Pearl. Temporal constraint networks. Artif. Intell.,

49(1-3):61–95, 1991.

[6] Eurocontrol. Modelling the turnaround process. CAED Deliverable D2, March 2007.

[7] F. Glover. Future paths for integer programming and links to artificial intelligence.

Computers and Operational Research, 13:533–549, 1986.

[8] F. Glover. Tabu search—part I. ORSA Journal of Computing, 1:190–206, 1989.

[9] Luke Hunsberger. Algorithms for a temporal decoupling problem in multi-agent planning.

In Proceedings of the Eighteenth National Conference on Artificial Intelligence (AAAI-

2002), 2002.

[10] Luke Hunsberger. Group Decision Making and Temporal Reasoning. PhD thesis, Harvard

University, Cambridge, Massachusetts, June 2002. Harvard Technical Report TR-05-02.

[11] D. S. Johnson, C. R. Aragon, L. A. McGeoch, and C. Schevon. Optimization by simulated

annealing: An experimental evaluation; part II, graph coloring and number partitioning.

Operations Research, 39:378–406, 1991.

[12] Lina Khatib, Paul Morris, Robert A. Morris, and Francesca Rossi. Temporal constraint

reasoning with preferences. In IJCAI, pages 322–327, 2001.

[13] S. Kirkpatrick, C. D. Gelatt, and M. P. Vecchi. Optimization by simulated annealing.

Science, 220:671–680, 1983.

[14] Philippe Laborie and Malik Ghallab. Planning with sharable resource constraints. In IJCAI,

pages 1643–1651, 1995.

-49-


[15] M. D. Moffitt and M. E. Pollack. Applying local search to disjunctive temporal problems.

In Proceedings of the 19th International Joint Conference on Artificial Intelligence

(IJCAI-2005), pages 242–247, 2005.

[16] P. Morris. The breakout method for escaping from local minima. In Proceedings of the

11th National Conference on Artificial Intelligence (AAAI’93), pages 40–45, 1993.

[17] Paul Morris, Nicola Muscettola, and Thierry Vidal. Dynamic control of plans with

temporal uncertainty. In IJCAI, pages 494–502, 2001.

[18] Martha E. Pollack and Ioannis Tsamardinos. Efficiently dispatching plans encoded as

simple temporal problems. In Ioannis Vlahavas and Dimitris Vrakas, editors, Intelligent

Techniques for Planning, chapter IX, pages 296–319. Idea Group Publishing, 2005.

[19] B. Selman and H. Kautz. An empirical study of greedy local search for satisfiability

testing. In Proceedings of the 11th National Conference on Artificial Intelligence, pages

46–51, 1993.

[20] B. Selman, H. Kautz, and B. Cohen. Noise strategies for local search. In Proceedings of the

11th National Conference on Artificial Intelligence, pages 337–343, 1994.

[21] B. Selman, H. Levesque, and D. Mitchell. A new method for solving hard satisfiability

problems. In Proceedings of the 10th National Conference on Artificial Intelligence, pages

440–446, 1992.

[22] J.R. Steenhuisen and C. Witteveen. Coordinating planning agents for moderately and

tightly-coupled tasks. In ICAI07 (submitted), 2007.

[23] Kostas Stergiou and Manolis Koubarakis. Backtracking algorithms for disjunctions of

temporal constraints. Artificial Intelligence, 120(1):81–117, 2000.

[24] J. Thornton, M. Beaumont, A. Sattar, and M. Maher. Applying local search to temporal

reasoning. In Proceedings of the Ninth International Symposium on Temporal

Representation and Reasoning (TIME-02), pages 94–99, 2002.

[25] Ioannis Tsamardinos. A probabilistic approach to robust execution of temporal plans with

uncertainty. In SETN ’02: Proceedings of the Second Hellenic Conference on AI, pages

97–108, London, UK, 2002. Springer-Verlag.

[26] Ioannis Tsamardinos, Thierry Vidal, and Martha E. Pollack. CTP: A new constraint-based

formalism for conditional, temporal planning. Constraints, 8(4):365–388, 2003.

[27] Pim van Leeuwen. Requirements and design document for LEONARDO’s collaborative

decision making multi-agent system CDMMA. Technical Report NLR-TR-2003-653,

National Aerospace Laboratory NLR, January 2004.

[28] M. B. Vilain and H. Kautz. Constraint propagation algorithms for temporal reasoning. In

Proceedings of the Fifth AAAI, pages 377–382, Philadelphia, PA, 1986.

-50-


[29] Lin Xu and Berthe Y. Choueiry. Improving backtrack search for solving the TCSP. In

Francesca Rossi, editor, Principles and Practice of Constraint Programming - CP 2003,

volume 2833/2003 of Lecture Notes in Computer Science, pages 754–768. Springer Berlin

/ Heidelberg, 2003.

[30] Lin Xu and Berthe Y. Choueiry. A new efficient algorithm for solving the simple temporal

problem. In Tenth International Symposium on Temporal Representation and Reasoning,

pages 212–222, 2003.

-51-


Appendix A

In this appendix, we present the interested reader with theoretical details such as formal

theorems and definitions that were omitted from the main text for clarity and brevity. The

material we incorporate here is ordered by chapter and roughly follows the structure of the main

text.

Notes on Chapter 2

Definition A.1

The union of I and J, denoted by I ∪ J, admits only values that are allowed by either one of

them.

The intersection of I and J, denoted by I ⊕ J, admits only values that are allowed by both of

them.

The composition of I and J, denoted by I ⊗ J, admits only values t3 for which there exist t1 ∈ I

and t2 ∈ J such that t1 + t2 = t3.

Figure A.1 shows a graphical example of these operations. The composition operator is the most

difficult one to understand. If in this example the constraint ci1j1 corresponds to action a1 and the

constraint ci2j2 corresponds to action a2, then their composition ci1j1 ⊗ ci2j2 can be seen as the

total time the execution of a1 and a2 may take when executed immediately after each other.

-52-


Figure A.1: Union, intersection and composition.

Theorem A.1 An STP is consistent if and only if its distance graph contains no negative

cycles.

The proof of this theorem is simple: the inequality corresponding to a path in the distance graph

can be obtained by taking the sum of the inequalities of the edges on the path. A negative cycle

from xi to itself would result in the inequality xi − xi < 0, which cannot be satisfied. Conversely,

if there are no negative cycles, then the shortest path between each pair of vertices is well-

defined. For each two time points xi and xj these shortest paths satisfy d0i ≤ d0j + aij, so the

inequality d0i − d0j ≤ aij holds. Thus the tuple (d0,1, …, d0n) is a solution to the STP.

Definition A.2 A constraint cij1 is tighter than constraint cij2, denoted by cij1 ⊆ cij2, if all values

allowed by cij1 are also allowed by cij2. Similarly a network A is tighter than a network B,

denoted by A ⊆ B, if the partial order ⊆ is satisfied for all corresponding constraints.

Definition A.3 Two networks are equivalent if they have the same solution set.

Definition A.4 There is one unique network, that is the tightest network among all networks

equivalent to an STP, which is called the minimal network. In this network no constraints can

be made tighter without eliminating solutions.

It can easily be proven that the network represented by the d-graph is the minimal network.

Finding the d-graph can be done by applying the Floyd-Warshall algorithm [4] (Figure A.2) to

the distance graph, which results in the all-pairs-shortest-paths (APSP) matrix. Figure A.3

-53-


shows the APSP matrix of Example 2.1, which corresponds to its d-graph in Figure 2.3. The

Floyd-Warshall algorithm can also be used to detect negative cycles, by simply checking the

sign of the diagonal elements dii of this matrix, thereby checking the consistency of the STP.

Floyd-Warshall's algorithm

“Returns the all-pairs-shortest-paths matrix.”

1. for i := 1 … n

2. dii := 0

3. for i,j := 1 … n

4. dij := aij

5. for k := 1 … n

6. for i,j := 1 … n

7. dij := min{dij, dik + dkj}

8. return d

Figure A.2: All-pairs-shortest-paths algorithm.

x0 x1 x2 x3

x0 0 180 180 210

x1 -60 0 120 150

x2 -180 0 0 30

x3 -210 -30 -30 0

Figure A.3: All-pairs-shortest-paths matrix.

STP-Solution(STP =<X, C> )

“Returns an assignment to the STP variables that respects the constraints,

or INCONSISTENT if this is not possible.”

1. d := STP-consistency(<X, C>)

2. if d = INCONSISTENT

3. return INCONSISTENT

4. else

5. Impose an arbitrary ordering on X: x0, …, xn

6. Arbitrarily select a value τ0 ∈ [−∞, ∞] and assign x0 := τ0

-54-


7. Solution := {x0 := τ0}

8. for k:=1 … n

9. TimeWindow(xk) := ∩i=0k−1 τi + [− dk,j,di,k]

10. Arbitrarily select a value τk ∈ TimeWindow(xk)

11. Solution := Solution ∪ { { xk := τk}}

12. return Solution

Figure A.4: Algorithm for finding STP solutions.

Algorithm A.4 uses the STP-consistency algorithm, which applies Floyd-Warshall's algorithm,

and returns the all-pairs-shortest-paths matrix for a consistent STP and INCONSISTENT for an

inconsistent STP.

Improvements on the STP solution algorithm

If the problem that has to be solved is very large, or a solution is needed quickly, the algorithms

described in the previous sections may not be fast enough. Fortunately, several faster algorithms

for solving STPs are available. This section discusses the following improvements: edge

domination and the triangle rule, path consistency algorithms, network-based algorithms and

∆STP.

Edge domination and the triangle rule

Some edges can be removed from an STN without impacting the decomposability of the

network; these are said to be dominated. They can be identified using the triangle rule:

Theorem A.2 An edge xa → xc is dominated by some other edge if there is a variable xb such

that dab + dbc = dac and either dab < 0 or dbc ≥ 0.

Path consistency algorithms

Path consistency algorithms impose local consistency among subsets of variables [5]. The DPC

algorithm (Figure A.5) is a faster algorithm to detect whether the network is consistent. It is

very suitable to use as the consistency checking routine, instead of the Floyd-Warshall

algorithm.

-55-


Directional path consistency (DPC)

“Enforces directional path consistency.”

1. for k := n down to 1 by −1

2. for all i,j < k such that cik, ckj ∈ C

3.

4. C := C ∪ cij

5. if cij = ∅

6. exit (network is inconsistent)

Figure A.5: Directional path consistency algorithm.

Network-based algorithms

Network-based algorithms exploit the topology of the network. One of these approaches is

decomposition into non-separable components [5].

Definition A.5 A connected graph G = (V,E) is said to have a separation vertex v (sometimes

also called an articulation point) if there exist vertices a and b, a ≠ v and b ≠ v, such that all the

paths connecting a and b pass through v. In this case we also say that v separates a from b. A

graph which has a separation vertex is called separable, and one which has none is called non-

separable. The induced subgraph G' = (V', E') is called a non-separable component if G' is non-

separable and if for every larger V'', V' ⊂ V'' ⊆ V, the induced subgraph G'' = (V'', E'') is

separable.

An example of a separable graph is given in Figure A.6. Its decomposition into non-separable

components is given in Figure A.7.

-56-


Figure A.6: A separable graph.

Figure A.7: Decomposition into non-separable components.

Then each non-separable component can be solved independently, possibly by using more

efficient algorithms if the topology of the component allows so. The consistency of the overall

network and its minimal network can be found by combining their results.

∆STP

The ∆STP algorithm, which was developed by Xu and Choueiry [30], considers an STP as

composed of triangles. The basic idea of this algorithm is to represent an STP as a graph of

triangles, and work on this graph instead of the original STN. Such a graph can be obtained

from a triangulated version of the STN by representing each triangle by a vertex, and connecting

two vertices if the corresponding triangles in the STN share a common edge. Edges that are not

part of any triangle are omitted from the new graph. This is shown in Figure A.8.

-57-


Figure A.8: A temporal graph as a graph of triangles.

The ∆STP algorithm has the same power as Floyd-Warshall's algorithm, but with less effort, as

the algorithm doesn't require a complete graph.

-58-


Notes on Chapter 3

Preferences

Khatib, Morris, Morris and Rossi [12] introduce the semiring structure < A, +, ×, 0, 1 > to

formalise the process of combining local preferences into an overall preference, and comparing

solutions. In this semiring, a + b = max(a, b), a × b = min(a, b), 0 is its overall minimum and 1

is its overall maximum. This semiring structure allows a partial order relation ≤S over A to be

defined as a ≤S b if and only if a + b = b. Informally, ≤S makes it possible to compare tuples of

values and constraints, and a ≤S b can be read as b is equally good as or better than a.

When dealing with preferences, the intersection and composition operations have to be

redefined, in order to include the preference information.

Definition A.6 The intersection of two soft constraints c1 = < I1, f1 > and c2 = < I2, f2 >,

written , is the soft constraint , where

• is the intersection of intervals I1 and I2, and

• f(a) = f1(a) × f2(a) for all

The composition of two soft constraints c1 = < I1, f1 > and c2 = < I2, f2 >, written c1 ⊗S c2, is the

soft constraint < I1 ⊗ I2, f >, where

• r ∈ I1 ⊗ I2 if and only if there exists a value t1 ∈ I1 and t2 ∈ I2 such that r = t1 + t2, and

• f(a) = Σ{f1(a1) × f2(a2) | a = a1 + a2, a1 ∈ I1, a2 ∈ I2 }, where Σ is the generalisation of

+ over sets.

Another subclass of the STPP that is tractable is the class where the preference functions are

linear and the semiring chosen is such that its two operations maintain such linearity when

applied to the initial preference functions. Then the given STPP can be written as a linear

programming problem, solving which is tractable.

Definition A.7 A function f:R→R is semi-convex if for all constants c, the set {x | f(x) ≥ c}

forms a single interval in R.

Resources

In general one can distinguish two different approaches for solving MCM-SPs. Profile-based

approaches characterise resource utilisation demand as a function of time, identifying periods of

resource overallocation in this utilisation, and incrementally performing “levelling actions” to

(hopefully) ensure that resource usage peaks fall below the total capacity of the resources.

-59-


Clique-based approaches [14] build a “conflicts graph”. If this graph contains cliques that are

larger than the resource capacity, a conflict is detected.

-60-


Notes on Chapter 5

Definition A.8 Let X, XX and XY be sets of time-point variables. We say that XX and XY z-

partition X if:

• XX ∩ XY = { z }, where z = x0 = 0, and

• XX ∪ XY = X

Definition A.9 A temporal decoupling of the STN S = < X, C > is a pair of STNs, SX = < XX,

CX> and SY = < XY, CY >, such that:

• SX and SY are consistent,

• XX and XY z-partition X, and

• (Mergeable Solutions Property) Merging any solutions for SX and SY necessarily yields a solution for S.

Definition A.10 Given an STN S whose time-points X are z-partitioned by XX and XY, find sets

of constraints CX and CY such that < XX, CX > and < XY, CY > temporally decouple S.

Definition A.11 Let XX, XY and X be sets of time-points such that XX and XY z-partition X. Let

xi and xj be arbitrary time-points in X. The pair (xi, xj) is called an xy-pair if:

(xi ∈ XX and xj ∈ XY) or (xi ∈ XY and xj ∈ XX)

If, in addition, neither xi or xj is the zero time-point variable, then (xi, xj) is called a proper xy-

pair. A constraint (or edge), (xj − xi ≤ δ), is called an xy-edge if (xi, xj) is an xy-pair. An xy-edge

is called a proper xy-edge if the corresponding pair is a proper xy-pair. Finally, it is called tight

if the constraint can't be tightened further without making the problem inconsistent.

Hunsberger's algorithm uses a measure called the zero-path shortfall (ZPS), which can be

calculated for xy-edges. The ZPS indicates how much longer the path through the temporal

reference point z is than the shortest path from xi to xj. If the ZPS value is zero, then the path

through z is the shortest path (though other paths that are equally short may exist). In this case,

the edge is said to be dominated by a path through zero.

Definition A.12 Let E be a tight, proper xy-edge (xj − xi ≤ δ). The zero-path shortfall (ZPS)

associated with E is the quantity:

-61-


ZPS(E) = [d(xi,z) + d(z,xj)] − δ.

The following theorem shows that we can restrict our attention to tight, proper xy-edges, when

searching for a solution for a TDP (see [10] for the proof).

Theorem A.3 If d(xp,z) + d(z,xq) ≤ δ holds for every tight, proper xy-edge (xq − xp ≤ δ) in a

consistent STN, then d(xi,z) + d(z,xj) ≤ d(xi,xj) holds for every xy-pair (xi,xj) in that STN.

TDP algorithm

Given: An STN S whose time-points X are z-partitioned by the sets XX and XY.

1. Compute the APSP matrix D for S. If S is inconsistent, return INCONSISTENT and halt;

otherwise, initialise E to the set of tight, proper xy-edges in S, and continue.

2. Select a tight, proper xy-edge e = (xj − xi ≤ δ) from E whose ZPS value is positive. (If, in the

process, any edges in E are discovered that are no longer tight or that have a ZPS value of

zero, remove those edges from E.) If no such edges exist (i.e., if E has become empty), go to

Step 6; otherwise, continue.

3. Pick values δ1 and δ2 such that:

−d(z,xi) ≤ δ1 ≤ d(xi, z),

−d(xj,z) ≤ δ2 ≤ d(z,xj), and

δ ≤ δ1 + δ2 < d(xi,z) + d(z,xj).

4. Add the constraints, e1: z − xi ≤ δ1 and e2: xj − z ≤ δ2 to S, updating D accordingly.

5. Go to Step 2.

6. Return:

CX = Cd | XX = {( xj − xi ≤ d(xi, xj)) : xi, xj ∈ XX };

CY = Cd | XY = {( xj − xi ≤ d(xi, xj)) : xi, xj ∈ XY };

where C includes all constraints added in passes of Step 4, and D has been updated

accordingly.

Figure A.9: Basic TDP Algorithm.

Hunsberger's algorithm for solving TDPs is given in Figure A.9. The basic idea of this

algorithm is to iteratively reduce the zero-path shortfall for tight, proper xy-edges, until every

tight, proper xy-edge is dominated by a path through zero. This is done by repeatedly selecting a

-62-


tight, proper xy-edge e = (xi,xj) whose ZPS is larger than zero, and then adding new edges (xi,z)

= δ1 and (z,xj) = δ2, such that these form a new path from xi to xj through z that is shorter than the

previous shortest one.

This algorithm is sound, but in this form not complete. This means that if it terminates at Step 6,

then the constraint sets CX and CY will be such that < XX,CX > and < XY,CY > are a temporal

decoupling of S. However, the algorithm is not guaranteed to terminate, because although in

Step 3 the line δ1 + δ2 < d(xi,z) + d(z,xj) guarantees that the ZPS value always decreases, it does

not ensure that substantial progress will be made.

Two approaches exist to solve this problem: a Greedy and a Less-Greedy Strategy. The Greedy

Strategy always chooses δ1 and δ2 such that the zero-path shortfall will be eliminated entirely.

The Less-Greedy Strategy always reduces the zero-path shortfall by a fixed amount (unless it is

already smaller than this amount; then the ZPS value is eliminated entirely). Although this

strategy is slower than the Greedy Strategy, it can lead to more flexible solutions, because in

this case also other edges can contribute to reducing the ZPS value for e, thereby reducing the

risk of over-constraining the network.

Hunsberger has developed algorithms for several variants of this basic Temporal Decoupling

Problem [10]. These are described in the following sections.

Definition A.13 Let SX = (XX, CX), SY = (XY, CY), and S = (X,C) be STNs such that SX and SY

temporally decouple S. The decoupling of S by SX and SY is called a minimal temporal

decoupling if the following condition holds:

For any STNs S'X = (XX, C'X) and S'Y = (XY, C'Y) that temporally decouple S: if the constraints in

CX and CY entail the constraints in C'X and C'Y, respectively, then CX ≡ C'X and CY ≡ C'Y.

caed d2: modelling the turnaround processcaed d2 ... · literature review, the theoretical work is...

Documents