the eplex library and hybrid forms involving eplex

The EPLEX Libraryand Hybrid Forms Involving EPLEX

Introduction

lib(eplex)

An interface between ECLiPSe and an external LP/MIP

solver XPRESS-MP, a product by Dash Associates CPLEX, a product by ILOG SA

Motivation to have this link: Use state-of-the-art linear programming tools Use ECLiPSe for modelling Build hybrid solvers

Implementation Tight coupling, using subroutine libraries

Capabilities of these Solvers

Linear Programming Variables: continuous Constraints: linear (in)equalities Methods: Simplex (primal and dual), Newton Barrier

Quadratic Programming As LP, but quadratic terms in objective Methods: Newton Barrier

(Mixed) Integer Programming As LP, plus integrality constraints Methods: Branch-and-bound, cut generation

Mathematical Programming

500

300

400

200

100

400

300

10

89

7

5

11

5

35

108

7

Plantcapacity

Clientdemand

Transportationcost

minimize10 A1 + 7 A2 + 11 A3 + 8 B1 + 5 B2 + 10 B3 + 5 C1 + 5 C2 + 8 C3 + 9 D1 + 3 D2 + 7 D3

subject toA1 + A2 + A3 = 200B1 + B2 + B3 = 400C1 + C2 + C3 = 300D1 + D2 + D3 = 100

A1 + B1 + C1 + D1 500A2 + B2 + C2 + D2 300A3 + B3 + C3 + D3 400

A

B

C

D

1

2

3

Objective Function

Constraints

Leads to a matrix:•Each row is one constraint•Each column is one variable

Possible Uses From Within ECLiPSe

Black-box If problem is suitable for LP/QP/MIP as a whole But: Only one solution, non-incremental, rounding errors

Incrementality and multiple instances Results explicitly retrieved Multiple independent subproblems

Hybrid Solvers work on (possibly overlapping) subproblems Programmed cooperation strategy Data-driven triggering

Low-level interface

General Usage

Loading: :- lib(eplex). Loads interface with default solver XPRESS-MP 14

Differences between the underlying solvers are largely hidden

Documentation ECLiPSe Library Manual Tutorial chapter on eplex Reference Manual

Transportation Problem (black box solving)

:- lib(eplex).

main(Cost, Vars) :-Vars = [A1, A2, A3, B1, B2, B3, C1, C2, C3, D1, D2, D3],Vars :: 0.0..1.0Inf,

A1 + A2 + A3 $= 200,B1 + B2 + B3 $= 400,C1 + C2 + C3 $= 300,D1 + D2 + D3 $= 100,

A1 + B1 + C1 + D1 $=< 500,A2 + B2 + C2 + D2 $=< 300,A3 + B3 + C3 + D3 $=< 400,

optimize(min( 10*A1 + 7*A2 + 11*A3 + 8*B1 + 5*B2 + 10*B3 + 5*C1 + 5*C2 + 8*C3 + 9*D1 + 3*D2 + 7*D3), Cost).

Eplex Constraints

Constraints Vars :: Min..Max Expr1 $= Epxr2 eplex:(Expr1 =:= Epxr2) Expr1 $>= Epxr2 eplex:(Expr1 >= Epxr2) Expr1 $=< Expr2 eplex:(Expr1 =< Epxr2) integers(Vars)

Linear expressions X 123 3.4 +Expr -Expr E1+E2 E1-E2 E1*E2 sum( ListOfExpr ) ListOfExpr1 * ListOfExpr2

Be Aware of Conventions

In mathematical programming, non-negative variables are usually assumed as default

In ECLiPSe, the default is -1.0Inf .. 1.0Inf

Non-negative variables need to be declared, e.g. X :: 0.0 .. 1.0Inf

Common Arithmetic Solver Interface

=:=/2

>=/2

=</2

>/2

</2

=\=/2

::/2

$::/2

$=/2

$>=/2

$=</2

#::/2 #\=/2

#= /2 $\=/2

#>=/2, #>/2

#=</2, #</2

$>/2 $</2

integers/1

reals/1

suspend

ic

eplex

std arith

Black-box Optimizer

eplex:optimize(+Objective, -Cost)

Objective is min(Expr) or max(Expr) Runs the external solver as a black box Considers all $=, $>=, $=< constraints, their variables, the

variable bounds and the integers/1 constraints Computes an optimal solution for Objective Returns the cost Cost Instantiates the variables to the computed solution values Selects LP/QP/MIP depending on integers and

Objective

Black-box use of LP and MIP solver A linear problem

?- X+Y $>= 3, X-Y $= 0, optimize(min(X),Cost).

Y=1.5

X=1.5

Cost=1.5

A mixed integer problem?- X+Y $>= 3, X-Y $= 0, integers([X]), optimize(min(X),Cost).

Y=2.0

X=2

Cost=2.0

X

Y

Cost

Summary: eplex as black-box solver CLP modelling / LP or MIP solving

1. Do modelling and transformations in ECLiPSe 2. Load model into CPLEX/XPRESS/MP and solve using LP or MIP solver 3. Pass cost and solution values back to ECLiPSe

LP / MIP search

ECLiPSe External Solvervariables & bounds

cost

constraints

solution valuesX1 X2 ... Xm

=

=<

>=

= Cost

c1

c2

cn

Obj

IC-Parc 14

Modelling with CLP Parameterised Constraints

product1(ProdQ,Raw1Q,Raw2Q) :-

ProdQ = 3*Raw1Q + 4*Raw2Q.

Define new constraints from Old Conjunction

conjCons(X) :- cons1(X), cons2(X). Disjunction

disjCons(X) :- cons1(X).

disjCons(X) :- cons2(X). Existential quantification

exqCons(X) :-

zeroOne(B), cons1(X,B),cons2(X,1-B).

IC-Parc 15

Default Evaluation?- cons1(X,2).

cons1(X,Y) :- X$>=5, cons2(X,Y).

cons1(X,Y) :- X$=<0, cons2(X,Y).

cons2(X,Y) :- Y-X$=<2, X-Y$=<2.

CLP(R) Requirement Highly dynamic constraint solver: Add new variables and new constraints Repeatedly check global consistency Remove variables and constraints on backtracking

Consequence Constraint solving is costly

CLP(R)

IC-Parc 16

Making CLP(R) Efficient

Fix the number of variables Fix the constraints Only change variable bounds

=>

Mixed Integer Programming

IC-Parc 17

CLP Modelling, MIP Efficiency

Collect Constraints Parameterised constraint => Unfold Conjunction => Append Existential quantification => Keep variable Disjunction => ???

Pass to MIP Solver

IC-Parc 18

A CLP(R) Model

solve(W,X,Y,Z) :-imp(X,W), imp(Y,W), two(X,Y,Z).

imp(X,Y) :- X=<Y.

two(X,Y,Z) :- and(X,Y).two(X,Y,Z) :- and(Y,Z).two(X,Y,Z) :- and(Z,X).

and(X,Y) :- X>=1, Y>=1.

?- solve(W,X,Y,Z), W=0.

IC-Parc 19

Removing Disjunction from a CLP Model

solve(W,X,Y,Z) :-imp(X,W), imp(Y,W), two(X,Y,Z).

imp(X,Y) :- X=<Y.

two(X,Y,Z) :- and(X,Y).two(X,Y,Z) :- and(Y,Z).two(X,Y,Z) :- and(Z,X).

and(X,Y) :- X>=1, Y>=1.

?- solve(W,X,Y,Z), W=0.

solve(W,X,Y,Z, B) :-imp(X,W, B), imp(Y,W, B), two(X,Y,Z, B).

imp(X,Y, B) :- X=<Y+ 2-2*B.

two(X,Y,Z, B) :- [B1,B2,B3] :: 0..1,and(X,Y, B1), and(Y,Z, B2), and(Z,X, B3),B1+B2+B3 >= B.

and(X,Y, B) :- X+ 2-2*B >= 1, Y+ 2-2*B >= 1.

?- solve(W,X,Y,Z, 1), W=0.

IC-Parc 20

Removing Disjunction from a CLP(R) Model

Add boolean to all predicates solve(W,X,Y,Z, B) :- imp(X,W, B), imp(Y,W, B), two(X,Y,Z, B).

Call the goal with extra boolean=1 ?- solve(W,X,Y,Z,1).

Add M*(1-B) to inequationsimp(X,Y, B) :- X=<Y+ 2-2*B.

Replace disjunction with boolean inequations two(X,Y,Z, B) :-

[B1,B2,B3] :: 0..1, and(X,Y, B1), and(Y,Z, B2), and(Z,X, B3),

B1+B2+B3 >= B.

IC-Parc 21

The Small Steps from CLP(R) to MIP

(0) Input CLP(R) Model

(1) Remove DisjunctionsConjunctive CLP(R) Model

(2) UnfoldConjunction of linear constraints

(3) Send to different solversSolution!

Problems with Black-Box Approach Solvable constraint class severely limited

Pure LP/QP/MIP Numerical problems

The external solvers use floating-point numbers, subject to rounding errors Other ECLiPSe solvers are usually precise (intervals or rational numbers) Instantiating the ECLiPSe variables to inexact values may cause other

implementations of the constraints to fail! Lack of incrementality

Cannot find alternative optima Cannot add constraints or variables

MIP search is a straightjacket A complex search process inside the black box Hard to control (via dozens of parameters) Hard to add problem-specific heuristics

Unsuitable for solver cooperation!

Opening the Black Box

Code for optimize/2:

optimize(Objective, Cost) :-

eplex_solver_setup(Objective),

eplex_solve(Cost),

eplex_get(vars, VarVector),

eplex_get(typed_solution,SolutionVector),

VarVector = SolutionVector.

Incrementality Solver setup

eplex_solver_setup(+Objective)

Run solver once eplex_solve(-Cost) Computes a solution with Cost but does not instantiate variables

Access solution information Status, solutions, reduced costs, dual values, slack, statistics, etc. eplex_get(+What, -Value) eplex_var_get(+Var, +What, -Value)

New constraints and variables can now be added and the problem re-solved!

Traditional MIP branching

simplex solution:X = 4.2

X =< 4 X >= 5

At each node: Solve the continuous relaxation (ignoring integrality) with simplex Select an integer variable with fractional simplex solution Try two alternatives, with bounds forced to integers

Eventually, all variables will be narrowed to integers (if a solution exists)

Doing MIP in ECLiPSe

:- lib(eplex), lib(branch_and_bound).

main :-<setup constraints>IntVars = <variables that should take integral values>,Objective $= <objective function>,eplex_solver_setup(min(Objective)),eplex_solve(RelaxedCost), % initial simplex solvingObjective $>= RelaxedCost % apply resulting cost boundminimize(mip_search(IntVars, CostVar), CostVar).

mip_search(IntVars, CostVar) :-...% for each X violating the integrality conditioneplex_var_get(X, solution, RelaxedSol),Split is floor(RelaxedSol),( X $=< Split ; X $>= Split+1 ), % choiceeplex_solve(RelaxedCost), % simplex re-solvingCostVar $>= RelaxedCost, % apply new cost bound...

no integrality constraints!

Ok, but ...

Why run simplex once every time? there might be no significant change There might be more than one change

Solution: data-driven triggering, e.g. on instantiation instantiation far from relaxed solution bounds change bounds exclude relaxed solution

Triggering the solver automatically eplex_solver_setup(+Objective, ?Cost, +Options, +TriggerModes)

Objective min(Expr) or max(Expr)

Cost variable - it does not get instantiated, but only bounded by the solution cost.

TriggerModes inst - if a variable was instantiated deviating_inst - if a variable was instantiated to a value that differs more

than a tolerance from its LP-solution bounds - if a variable bound was changed deviating_bounds - if a variable bound was changed such that its LP-

solution was excluded by more than a tolerance. new_constraint - when a new constraint appears <module>:<cond> - waking condition defined by other solver, e.g. ic:min trigger(Atom) - explicit triggering

Using trigger conditions Example

?- X+Y $>= 3, X-Y $= 0, eplex_solver_setup(min(X), X, [], [inst]).

Y = Y{1.5}

X = X{1.5}

Delayed goals:

lp_demon(…)

Yes.

?- X+Y $>= 3, X-Y $= 0, eplex_solver_setup(min(X), X, [], [inst]), X=2.0.

Y = Y{2.0}

X = 2.0

Delayed goals:

lp_demon(…)

Yes.

Eplex solver as compound constraint

X1 X2 ... Xm

=

=<

>=

= Cost

c1

c2

cn

Obj

solver

setup

ExternalSolver

Solver triggered by events, then:

• new bounds and constraints are sent to the external solver

• external solver is run

• cost bound (or failure) is exported

• solution values are exported and ECLiPSe variables annotated (optional)

More Elegant Implementation of MIP

main :-<setup constraints>IntVars = <variables that should take integral values>,CostVar = <objective function>,eplex_solver_setup(min(Objective), CostVar, [], [bounds]),minimize(mip_search(IntVars), CostVar).

mip_search(IntVars) :-...% for each X violating the integrality conditioneplex_var_get(X, solution, RelaxedSol),Split is floor(RelaxedSol),( X $=< Split) ; X $>= Split+1 ), % choice...

No explicit simplex calls, no auxiliary parameters to search procedure Standard CLP search scheme - other choices/constraints can be added now

Control Flow with Constraint Propagation

Search/Choice

Propagation phase

Search/Choice

constraints

Eplex instance demon can be integrated similar to a global constraint

eplex instances

Hybridisation

Solver Cooperation in ECLiPSe

Why Use Multiple Solvers?

Real problems comprise different subproblems Different solvers/algorithms suit different subproblems

Global reasoning can be achieved in different ways Linear solvers reason globally on linear constraints Domain solvers support application-specific global constraints

Solvers complement each other Optimisation versus feasibility New and adapted forms of cooperation (e.g. Linear relaxation as a heuristic)

How to Use Multiple Solvers

Problem Decomposition Send subproblem constraints to subproblem solver e.g. Continuous/discrete circuits; Process scheduling

Redundant Solving Send a constraint to more than one solver e.g. Hoist scheduling; Progressive Party Problem

Global Constructive Search Hybrid Forms

Root Node

Node1

Node2

Some of these leaf nodes are our solutions

Add constraintand wake solvers

Cooperating Solvers: Intersecting Subproblems

X

Y

Z

C1

C2

Subproblem1 Subproblem2

Cooperating Solvers: Copied Variables

X1

Y

Z

C1

C2

Solver1 Solver2

X2

Keep X1 and X2 in stepCommunicate eventsCommunicate information


X1

Y

Z

C1C2

Linear Solver Interval Solver

X2

Info on “X”

X1 >= 10.5

X >= 10.5

X2 >= 10.5X2 >= 11

X1 >= 11

integer(X2)X1 >= 10.5

X2 >= 11

FD and Linear Solver Cooperation (within a Global Constructive Search)

Motivation Linking through Channeling Constraints Forms of Cooperation

Motivation for FD Linear Comunication

Performance Behaviour

IC-Parc 44

Motivation for FD Linear Communication:Performance FD

e.g. interval propagation more general constraints handle integers directly Favourable example:

Variable Bounds: [X1,…,X100] :: 1..100

Previous Constraints: X1 < X2 , … , X98 < X99 Resulting Bounds: X1 :: 1..2, …, X99 :: 99..100

New Constraint: X1 >= 3 Result (1 step): failure!

Linear e.g. Simplex, Gauss restricted class of constraints finds optimum without search Favourable example:

Variable Bounds: [X1,X2] :: 1..100

New Constraints: X1 > X2, X2 > X1 Result (1 step): failure!

IC-Parc

FD and Linear Constraint Solving Performance

Add N variables and trivial constraints N = 100, 200, 500, 1000, 2000, 5000, 10,000, 20,000, 50,000

The Constraints for each variable X[J] do

X[J]::1..N, X[J] >= X[J-1].

The Solvers FD CLPQ CPLEX (run once, after posting ALL constraints) CPLEX (incremental)

IC-Parc

Performance Figures (FD) - X i+1>=Xi

-4

-3.5

-3

-2.5

-2

-1.5

-1

-0.5

0

0.5

2 2.3 2.7 3 3.3 3.7 4 4.3 4.7

Log. # Constraints Added (100 - 50000)

CLPQ

Inc-CPLEX

CPLEX

FD

Log.Time perConstraint

IC-Parc

The Less Trivial Case - N Propagation Steps per Constraint

Add N variables and constraints N = 100, 200, 500, 1000, 2000, 5000, 10,000, 20,000, 50,000

The Constraints for each variable X[J] do

X[J]::1..N, X[J]-1 >= X[J-1].

The Solvers FD CPLEX (run once, after posting ALL constraints) CPLEX (incremental)

IC-Parc

Performance Figures (FD) - X i+1>Xi

-3.5

-3

-2.5

-2

-1.5

-1

-0.5

0

2 2.3 2.7 3 3.3 3.7 4 4.3 4.7

Log. # Constraints Added (100 - 50000)

FD - Xi+1>Xi

Inc-CPLEX

CPLEX

Log.Time perConstraint

Motivation for FD Linear Comunication

Performance Behaviour

IC-Parc 50

One-machine SchedulingTask 1 = Start-time 0..15, Duration 5Task 2 = Start-time 0..15, Duration 15,

Either Task1 must precede Task2:

0 5 10

15

20

Or Task2 must precede Task1:

0 5 10 15 20

Constraint: no_overlap(S1,5,S2,15).

25

IC-Parc 51

Representing Disjunction with Auxiliary Boolean Variables

no_overlap(S1,D1,S2,D2) :- S1 >= S2+D2.no_overlap(S1,D1,S2,D2) :- S2 >= S1+D1.

Choose a “large” number MIntroduce variables [B1,B2] :: 0..1Replace disjuction with conjunction:

no_overlap(S1,D1,S2,D2,B1,B2) :- S1+M-B1*M >= S2+D2,S2+M-B2*M >= S1+D1,B1+B2>=1.

Example:[S1,S2] :: 0..4, no_overlap(S1,3,S2,5,B1,B2), B1=1

=> fail!

Communicating Linear and FD Solvers

Optimisation Integer Feasibility

X,Y::0..10Y>= 2*XX+Y >= 5Cost = min(X+2*Y)

FD

Linear

Cost = min(S1)

Cost >= 0

Cost ::0..30

Cost >= 25/3

S1,S2::0..4, B1,B2::0..1S1 + 10 - B1*10 >= S2 + 3S2 + 10 - B2*10 >= S1 + 5B1 + B2 >= 1

B2=0, B1=1S1 :: 3..4, S2 ::0..1

IC-Parc 53

Hoist Scheduling

Each product must be dipped in a sequence of tanks.

IC-Parc 54

Disjunctive Constraint in Hoist Scheduling

Period = P1 Hoist

0T1 T2

PP+T1 P+T2

Disjunctive Constraint on actions a and b :T2 >= P+T1+timefull12 + timeempty23

or P+T1 >= T2+timefull34 + timeempty41

action a

action b

1 2 3 4

1 2 3 4

IC-Parc 55

Disjunctive Constraint in Hoist Scheduling

Period = P2 Hoists

0 T1 T2

P P+T1 P+T2

Disjunctive Constraint on actions a and b :T2 >= P+T1+timefull12 + timeempty23

or P+T1 >= T2+timefull34 + timeempty41or H1 < H2

action a: hoist H1

action b: hoist H2

1 2 3 4

1 2 3 4

IC-Parc 56

Hoist Performance

CP solver MIPsolver

CP/MPsolver

1 hoist1 track

96 s 10 s 51 s

2 hoists1track

> 10 min 34 s 96 s

2 hoists2 tracks

> 10 min > 10 min 152 s

Hoist Robustness -Algorithm

100 Randomly Generated 2-hoist 2-track Problems

Optimal Solutions Found 100

Minimum Time 167 secs

Maximum Time 1146 secs

Average Time 314 secs

Hoist Robustnes - Model Benchmark Hoist Scheduling Problem Tank Capacities Two hoists on one track Multiple hoists on multiple tracks

FD/Linear Hybrid Previous approaches

Same basic model for each problem class

Completely different models

Different Models in FD and Linear

X1

X2

X3

X4X5

X6

0 5 2 4 1 7

5 0 4 7 2 5

2 4 0 4 6 1

4 7 4 0 3 5

1 2 6 3 0 2

7 5 1 5 2 0

Distances Table: Data

X1

X2

X3

X4

X5

X6

X1 X2 X3 X4 X5 X6

TSP Problem: Find shortest route

ECLiPSe Syntax

Iterationforeach(El,[a,b,c,d]) do write(El),write(‘ ‘).

for(K,1,4) do write(K), write(‘ ‘).

for(K,1,4),foreach(El,List) do El=K

Const=a, (foreach(El,List), for(_,1,4), param(Const) do El=Const)

Const=a, (foreach(El,List), for(_,1,4) do El=Const)

for(K,1,4),for(J,1,4) do write(K-J),write(‘ ‘).

multifor([K,J],[1,1],[3,3]) do write(K-J),write(‘ ‘)

a b c d

1 2 3 4

List = [1,2,3,4]

List = [a,a,a,a]

1-1 2-2 3-3 4-4

1-1 1-2 1-3 2-1 2-2 2-3 3-1 3-2 3-3

List = [_,_,_,_]

ECLiPSe Syntax

ArraysStruct = f(a,b,c,d), X is Struct[2].X=bMatrix = m(f(11,12),f(21,22),f(31,32)), X is Matrix[3,2]X=32Matrix = m(f(11,12),f(21,22),f(31,32)), X is Matrix[1..3,2]X=[12,22,32]dim(M,[2,2]), A is M[1,2] M = []([](_,A),[](_,_))dim(M,[2,3]),( multifor([K,J],[1,1],[2,3]), param(M) do X is M[K,J], X=K-J)M = []([](1-1, 1-2, 1-3), [](2-1, 2-2, 2-3))

TSP Problem – ECLiPSe FD Design Model

length(Vars,6), ic:(Vars :: 1..6), ic:alldifferent(Vars),

length(Dists,6), ic:(Dists :: 1..10),

( for(J,1,6),

foreach(SJ,Vars),

foreach(DJ,Dists),

param(Data)

do

ListJ is Data[J,1..6]), ic:element(SJ,ListJ,DJ) ),

ic: (Cost =:= sum(Dists))

For example:ic:element(S3,[2,4,0,4,6,1],D3)

TSP Problem – ECLiPSe Linear Design Model

dim(Bools,[6,6]), Bools::0..1,( for(J,1,6), param(Bools) do eplex: (Bools::0..1), eplex: (sum(Bools[J,1..6]) =:= 1), eplex: (sum(Bools[1..6,J]) =:= 1) ),( multifor([I,J],[1,1],[6,6]), foreach(C,Costs), param(Bools,Data) do C = Bools[I,J]*Data[I,J] ),eplex:(Cost =:= sum(Costs)).

Mapping FD Variables to Booleans

[ic,eplex]: (Var :: 1..N),

length(Bools,N), eplex: (Bools::0..1), eplex: (sum(Bools) =:= 1),

(foreach(B,Bools), for(Val,1,N), for(E,Exprs) do E = B*Val),

eplex: (Var =:= sum(Exprs)).

Channeling constraint in linear solver


Var

Bk

Z

C1C2

Linear Solver FD Solver

Var

Info on “Var”

Bk=1

Var=kVar=k

Channeling constraint in linear solver

Mapping FD Variables to Booleans

ic: (Var :: 1..N),

length(Bools,N), [ic,eplex]: (Bools::0..1), eplex:(sum(Bools) =:= 1),

( foreach(B,Bools), for(Val,1,N), param(Var) do ic: =:=(Var, Val, B)).

Channeling constraint in FD solver

Information Communicated from FD to Linear Solvers

Variable Bounds Variable instantiation

Variable remains in linear solver, with identical bounds

Linear Constraints Delay MLLP

Communicating FD to LP: Delay

X*B >= Y As soon as B is instantiated to 1, send X>=Y to linear solver As soon as B is instantiated to 0, send 0>=Y to linear solver As soon as X is instantiated, send X*B >=Y to linear solver

ECLiPSe Syntax suspend(eplex: (X*B>=Y), 3, [X,B] -> inst)

Information Communicated from Linear to FD Solvers

Directly Cost Bounds

Indirectly Reduced costs => Var ≠Val often by fixing Bval=0

Reduced Cost Pruning

Best solution so far

Relaxed OptimumReduced Cost

Infe

asib

leR

egio

n

Val

ues

ru

led

ou

tb

y re

du

ced

co

st

Cost

Value of boolean

0 0.2 0.4 0.6 0.8 1

Communicating Linear and FD Solvers

Optimisation

X,Y::0..10Y>= 2*XX+Y >= 5Cost = min(X+2*Y)

FD

Linear

Cost ::0..30

Cost >= 25/3

IC-Parc 75

Branch-and-bound (incremental)

Lower bound(relaxed solution)

Cost

1

First solution

Better solution

2Iterations:

Solu-tions

3

Optimal solution

4

No solution(Proof of optimality)

Global Constructive Search – FD and Linear Solvers

Root Node

Node1

Node2

Some of these leaf nodes are our solutions

Add constraintand wake FD and linear solvers

Reasoning at each node:RepeatReduce FD domainsTighten linear relaxed cost boundUntil fixpoint

Linear and FD Constraints as Fixpoint Operators

Information

FD fixpoints

Linear Fixpoints

FD&Linear

Information Communicated from FD and Linear to Search Engine

FD Domain size Number of active constraints

Linear Relaxed solution Reduced costs => “regret”

Combining Linear and FD – Horses for Courses

Problem Progressive Party

Cabinet Assignment

Set Partitioning

CP > 5 mins 9.27 secs 64.68 secs

LP > 5 mins > 5 mins 0.18 secs

CP & LP 91.5 secs 13.2 secs 0.71 secs

Hybridising ic and eplex

ic ?- ic:(X=\=Y)

eplex ?- eplex:(X>=3)

Redundant ?- [ic,eplex]:(X>=3), ic:(X=\=Y)

Control Flow with Multiple Solvers

Search/Choice

Solver phase withcommunication

Solver1

Solver2

Search/Choice

A Hybrid Algorithm Set up constraints

Make choices in ECLiPSe code programmer specified variable/value choices

Apply interval propagation, e.g. lib(ic) Narrowed Bounds Empty intervals Instantiated integers

Solve the continuous relaxation with Simplex Global Consistency (of continuous relaxation) Lower bound on cost “Suggested values” (optimising continuous relaxation)

Flight Schedule Retimer

Activity Overlaps ~ Fixed TimesS1

S2S3

E1E2

E3

No. ofResourcesRequired

Time

321

Activities

321

S1 S2S3

Potentialresourcebottleneckpoints

Activity Overlaps ~ Variable Times

S1S2

S3

E1E2

E3

PossibleNo. ofResourcesRequired

321

S1 S2S3

Unknown start times

Constraints on Departure Times(linear)

Precedence Dep1 + time =< Dep2

Maximal delay Dep1 + time >= Dep2

Minimize Perturbation

Change >= Old – New,

Change >= New – Old,

minimize(Change)

Aircraft Constraints

Start End

Flights

T1

T2

T3

T4

T5

S1 = start of T1

Resources used at S1:B1j = 1 if (S1>=Sj and S1=<Sj+Dj)B1j = 0 otherwise.

Resource constraint at start of T1:

1+B12+B13+B14+B15 = T1R =< 2

Resource Limit = 2

Tentative Values

:- lib(repair).

X tent_set 2

X tent_get Tent

X tent_is Y+1.

Load the “repair” library

Set the tentative value of X

Get the tentative value of X

Propagate from the tentative value of Y to the tentativeValue of X

Resource Constraints

Start End

Machine

Tasks

T1

T2

T3

T4

T5

Start of T1

overlap(S1,S2,D2,B12) :- B12 tent_is (S1>=S2 and S1=<S2+D2).

Resource usage at start of T1:

R1 tent_is1 + B12 + B13 + B14 + B15

Resource Limit

eplex Setting Tentative Values

set_ans_to_tent :- eplex_get(vars,Vars), eplex_get(typed_solution,Solution), Vars tent_set Solution.

Tentative Values as Heuristic

label_heur(List) :-choose_worst(List,res(RN,S1,S2,D2)),(S2 $>= S1 ; S1 $>= S2+D2),label_heur(List).

choose_worst(List,Resource) :-member(res(RN,_,_,_),List),RN tent_get Load,( foreach(res(RM,_,_,_),List), param(Load)

do RM tent_get Load2, Load2=<Load

).

Probing

1. Send temporal constraints to linear solver

2. Set tentative values to linear optimum S1 = 10, S2 = 8, S3 = 12, S4 = 13, S5 = 7

3. Propagate tentative values B12 = 1, B13 = 0, B14 = 0, B15 = 1 => T1R = 3 B21 = 0, … => T2R = 2

4. Identify bottleneck (maximum excess overlap) T3R = 4

5. Add precedence constraint on two bottleneck tasks S3 >= S2+D2

Comparison with Integer/Linear Programming

Encode this using linear constraints B1j = 1 if (S1>=Sj and S1=<Sj+Dj) B1j = 0 otherwise

Impose integrality constraints on the Bij Solve linear constraints Set tentative values to linear optimum Choose a non-integer Bij Add precedence constraint:

Si >= Sj+Dj

Results – Integer/Linear vs Combined Algorithm: LP Nodes

0

2000

4000

6000

8000

10000

12000

14000

16000

18000

20000

10 20 50

Number of Activities

LP N

odes

Integer/Linear Programming

Unimodular Probing

Results: Commercial Aircraft UtilisationProblems

Aircraft Utilisation up to 1000 activities, total of over 70 resources, 6 types

Saved a plane in each of two fleets Used by BA for IATA negotiations

The Future

A Platform for Three Communities Operations Research Metaheuristics Computational Intelligence

Research Issues Algorithm Encapsulation and Hybridisation User Languages

Modelling Search Programming Constraint Behaviours

System Building Research Community Industrial Applications

The Near Future!

HAL/Mercury User languages Algorithm Encapsulation and Hybridisation System Building

Applications Supply Chain Optimisation

Patrick Corp., Bluescope Steel, Berri,… Inventory and Transport Optimisation

IBM/Qantas NAB/Chubb

Construction Scheduling BLL

NICTA Constraint Technology

the eplex library and hybrid forms involving eplex

Documents