La Programmation Logique par Contraintes Module IA

La Programmation

Logique par Contraintes Module IA

CHIP

P.De Loor

2004

Plan

• Limites de la programmation logique

• La Résolution de contraintes

• CHIP

– généralités

– contraintes domaines finis – (contraintes rationnelles) – exemples

• Bibliographie

programmation logique

• Petit programme prolog

fact(0,1).

fact(X,Y):- X2 is X-1, fact(X2,Z), Y is Z*X.

?- fact(3,X).

X = 6

?- fact(Y,6).

[WARNING: Arguments are not sufficiently instanciated]

Exception: ( 9) _L168 is _G123-1 ?

Limites de la

programmation logique

• « is » n ’est pas qu ’une unification

copie(X,Y):- X is Y.

?- copie(56,Y).

[WARNING: Arguments are not sufficiently instanciated]

Exception: ( 9) _L169 is _G127 ?

programmation logique

• Prolog ne « raisonne » pas sur l ’arithmétique.

fact(0,1).

fact(X,Y):- X2 = X-1, fact(X2,Z), Y = Z*X.

?- fact(3,X).

: :

Call: (11)fact(3-1-1-1, _L195) ? creep Call: (12) 3-1-1-1==0 ? creep

Fail: (12) 3-1-1-1==0 ? creep

!!!

Limites de la

programmation logique

• Petit programme CHIP

fact(0,1).

fact(X,Y):- X ^> 0,

X2 ^= X-1, fact(X2,Z), Y ^=Z*X.

?-fact(5,X).

X=120 ?

?-fact(Y,120).

Y=5 ?

programmation logique

• Maximiser une solution en prolog ?

maximise(Val):-

findall(Y,contraintes(_,Y,_),LV), max(LV,Val).

contraintes(X,Y,Z):- X + Y < 5,

X + Z > 7.

max([X|L], X) :- max(L,Y), X>=Y.

max([X|L], Y) :- max(L,Y), X<Y.

max([X],X).

Yes

?- maximise(V).

[WARNING: Arguments are not sufficiently instantiated]

Exception: ( 12) _G216+_G217<5 ?

Infinités de valeurs pour X, Y et Z !!!

Limites de la

programmation logique

• Une solution en CHIP

maximise(Y):- positive(X), X+Y #< 5, X+Z #> 7, rmax(Y).

?- maximise(Y)

Y = 5

CHIP possède des algorithme de résolutions et d ’optimisation (gauss, simplex).

de contraintes

Mathématiques Mathématiques

Recherche

Opérationnelle Recherche

Opérationnelle

Programmation par Contraintes

Programmation par Contraintes

Informatique Informatique

Intelligence Artificielle Intelligence Artificielle

Type d ’applications

• Gestion du temps

– agendas,

– emploi du temps, – …

• Affectation de ressources

– gestion de personnel, – gestion de moyens de

transports, – ...

• Planification et ordonnancement

– production, – itinéraires

– ordonnancement d ’atelier

• Optimisation

– optimisation de moyens,

– optimisation de coûts, – placement financiers, – ...

Outils Industriels

Nom Société Domaines Langages

Charme SNI

Chip

Prolog III Ilog Solver Chleo

Bull Siemens Cosytec PrologIA Ilog

Axia

D

D,R,B D,R,B R,B D D

C-like Prolog Prolog Prolog C++

C

Applications Industrielles

• Gestion de production

– Cuisine Delacrois : optimisation de la découpe de bois.

– Dassault Aviation : planification d ’une chaine d ’assemblage d ’avions,

– Michelin :

ordonnancement de production,

– Siemens : placement et routage de VLSI

• Logistique

– Alcatel Cables : gestion des stocks,

– Renault : planification de livraison de pièces détachées,

• Gestion de personnels

– Air France : roulement d ’équipages

– DGA : planification de cariières

– National Westminster Bank : planification de stage.

Contrainte

• Langages impératifs

void f(&x,&y) { x = y + 2;

}

• f sait calculer x

• f ne sait pas calculer y

Impératif versus Contrainte

• Contraintes : (exemple Ilog Solver .. 5)

model.add(x == y + 2);

• Si y est connue x sera déterminée

• Si x est connue, y sera déterminée

• Si x et y sont inconnues, la contrainte sera mémorisée

Contraintes

• U = R * I

U

R

I

= *

fixe

Contraintes

• Arithmétique

u = r*i

x = 3 * exp(sin(k)) + x^5 – Algorithmes de résolutions

Résolution de domaines simplex

recuit simulé

algorithmes génétiques

Contraintes

• Ensemblistes

P = ensemble de pilotes p_j= (nom_j, age_j) V = ensemble de vols v_i = (avion_i, pilote_i..) contraintes :

Pour chaque i : pilote_i ∈m

Pour tout couple {v_i v_j}_(j≠i) : pilote_i ≠ pilote_j

P V

(747A, jean) (A320C, tom) ...

(tom, 45) (marcel, 37) (jean, 35) . . .

Contraintes

P V

Tous différents Appartient a

pilote pilote

Optimisation

• Minimiser un critère

• Respecter les contraintes

x = 3 * exp(sin(k)) + x^5 k = z / 3 + 2*x

k > 10

minimiser(x).

programmation par contrainte

Algorithme s de résolution

=

boite noire problème

contraintes

résultat

Langage support (C++, Prolog ...)

Exemple de contraintes

• Résolution d ’un système linéaire

départ arrivée

vitesse : V ?

temps : T

distance : D ?

Problème :

1 - si V est diminué de 20 km/h alors T augmente de 3 min

2 - si V est augmentée de 20 km/h alors T diminue de 2 min

Mise sous forme de contraintes

• D = V*T

• D=(V-20)*(T+3)

• D=(V+20)*(T-2)

Système linéaire de contraintes :

• 3V-20T-60 = 0

• -2V + 20T - 40 =0

V=100km/h et D=20km

Contraintes de type x=log(y) ou z = T^k

???

Découpe Industrielle

• Une barre :

L k

l1 l1 l2 l2 l2 chu

te

• Une commande = bi barres de longueur li

• Il faut honorer m commandes

• On dispose de différentes barres de longueur standards

• Trouver les configurations de découpe j pour limiter les chutes….

Contraintes :

Lk

l1 l1 l2 l2 l2 chute

• Chute pour une configuration j :

• cj = Lk -

Σ

• Nombre de configuration cj = xj

xj et les différentes configurations sont à définir !!!

En minimisant : z=

Σ

En satisfaisant la demande :

Σ

(i=1,…m)

i=1,m

j j

Problème des coûts fixes

Client j : demande dj Localisation

possible i : coût fixe fi capacité Mi

Localisation possible

Localisat ion

possible

Localisation possible

Localisation possible

n

coût cij

Généralité sur la PLC

• Ré-utilisation de la

programmation logique, syntaxe PROLOG.

• CLP(X) concepts : J.L Lassez et J. Jaffar 87.

• Preuves :

– Les solutions trouvées sont corrects.

– Toutes les solutions sont trouvées.

généralités

• Version industrielle de la PLC

• Prolog + contraintes

• Société COSYTEC

• Contraintes sur Domaines

• Contraintes sur Rationnels

• Contraintes Booléennes

• Classes

• Interface Oracle, C, Xwindows

• Concurrents : ILOG-SOLVER, PROLOG IV

• + générique, + I.A. (déclaratif)

Domaines finis : Applications Types

• Emplois du temps

• Planification (capacités finies)

• Placement d ’objets ou de formes

• Optimisation de stratégies (jeux)

• Coloriage de cartes

• Optimisation de parcours

• Problème d ’assignation

domaines finis

• Un domaine

– est une variable X

– peut avoir plusieurs valeurs entières.

– le nombre des valeurs est fini.

– possède des bornes min et max

• Les contraintes peuvent être – arithmétiques,

– symboliques, – globales …

Contraintes sur les

domaines finis : exemple

• Puzzle Cryptarithmétique

S E N D + M O R E ---

M O N E Y

• Chaque caractère est un chiffre (0..9)

[S,E,N,D,M,O,R,Y] :: 0..9

domaines finis : exemple

• Les contraintes :

• Tous les chiffres sont différents

alldifferent([S,E,N,D,M,O,R,Y])

• Les nombres ne commencent pas par 0.

S#\=0, M#\=0

• L ’addition doit être satisfaite.

1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E #=

10000*M + 1000*O + 100*N + 10*E + Y

Contraintes sur les

domaines finis : exemple

crypt :-

[S,E,N,D,M,O,R,Y]::0..9,

alldifferent([S,E,N,D,M,O,R,Y]), S#\=0, M#\=0,

1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E #=

10000*M + 1000*O + 100*N +10*E + Y, labeling([S,E,N,D,M,O,R,Y],0,first_fail,

indomain), % vu après

writeln([S,E,N,D,M,O,R,Y]).

allSolutions :-findall(_,crypt,_).

finis

• X est compris entre 1 et 10

X::1..10

• Liste de variables

[X1,X2,X3]::1..10

• Limite des domaines entre 0 et 100000 (couteux)

Types de domaines finis

• Suite d ’entiers consécutifs

X::A..B,

(explicitement représentés en mémoire)

• Ensemble de valeurs

X::[V1, V2, V3],

(restriction a priori de domaine : grande liste = couteux)

• Intervalles

X::A:B,

(Seuls le min et le Max sont mis à jour)

(très peu coûteux pour des grands domaines)

(impossibilité d ’enlever des valeurs intermédiaires)

Domaines : exemples

wflags(64). (force l ’affichage des domaines)

?- X::1..5.

X = X in {1..5} ?

?- X::1:5.

X = X in [1..5] ?

?- X::[5,9,2] ?

X = X in {5,9,2} ?

Termes linéaires sur des domaines finis

• Un entier naturel (c)

• Un domaine (X)

• c * X ou X * c

(c : entier, X : variable)

• X + Y

• Pas de négatifs ni de signes « - » dans un terme.

sur les variables

integer(X)

– réussit si X est un entier dvar(X)

– réussit si X est une variable à domaine fini

dvarint(X)

– réussit si X est un entier ou une variable à domaine fini.

Unification sur les domaines finis

• Domaine X et variable « libre » Y

– Y devient un domaine équivalent à X.

• Domaine X et entier c

– si c appartient au domaine, X devient l ’entier c – sinon échec de l ’unification (fail)

• Domaine X et Domaine Y

– calcul de leur intersection – si intersection vide, échec

– si l ’intersection est une valeur, X et Y deviennent un entier de cette valeur

– si l ’intersection est un ensemble, les domaines de X et Y sont réduits à cet ensemble

arithmétiques sur les domaines

X, Y : domaines c : variable entière

X #< Y X #<= Y X #> Y X #>= Y X #= Y X #\= Y

X #\ Y + c

arithmétiques sur les domaines

distance(X,Y,Comp,Dist) – distance : |X-Y|

– Comp : (#>,#=,#<) – Dist : entier

notin(X, From, To)

– les valeurs de X ne sont pas entre From et To.

X::1..10, notin(X,5,9) . X = X in {1..4,10}?

X::1:10, notin(X,5,9).

No (more) solutions.

Résolution

[A,B,C]::0..10, A#>B+2,

B#<7, C#<B.

A:{0,1,2,3,4,5,6,7,8,9,10}

B:{0,1,2,3,4,5,6,7,8,9,10}

C:{0,1,2,3,4,5,6,7,8,9,10}

A:{3,4,5,6,7,8,9,10}

B:{0,1,2,3,4,5,6,7}

C:{0,1,2,3,4,5,6,7,8,9,10}

A#>B+2,

[A,B,C]::0..10

Résolution

[A,B,C]::0..10, A#>B+2,

B#<7, C#<B.

A:{3,4,5,6,7,8,9,10}

B:{0,1,2,3,4,5,6}

C:{0,1,2,3,4,5,6,7,8,9,10}

A:{4,5,6,7,8,9,10}

B:{1,2,3,4,5,6}

C:{0,1,2,3,4,5}

C#<B, B#<7,

A#>B+2

Grosse

différence Avec le

chaînag

e classique

PLC

• Résolution des domaines

• Propagation/mémorisation des contraintes

• Retour Arrière

• Optimisation

+

+

+

Contraintes symboliques sur les Domaines

allDifferent(List)

atleast(N,List,V)

– au moins N de List ont la valeur V

atmost(N,List,V)

– au plus N de List ont la valeur V

maximum(X,List)

– le domaine X possède la plus grande valeur de List.

minimum(X,List)

circuit(L),

- les éléments de L doivent être un circuit Hamiltonien.

38?- length(L,5), L::1..5, circuit(L),

labeling(L,0,first_fail,indomain).

L = [2, 3, 4, 5, 1] ? ; L = [2, 3, 5, 1, 4] ? ; L = [2, 4, 1, 5, 3] ? ; L = [2, 4, 5, 3, 1] ? ; L = [2, 5, 1, 3, 4] ? ; L = [2, 5, 4, 1, 3] ? ; ...

sur les domaines

1 2

4

5 3

Element

element(Index, List, Value)

Index List Value

0 1 2 3 4 5 6

456 45 123 789 1 23 4

45

Si Index vaut 1, Value vaut 45

Si Index vaut entre 4 et 6, Value vaudra 1, 23 ou 4

(domaines) (domaines)

Prédicats de Choix

indomain(X)

– choix d ’une valeur de X

– par défaut : commence par la plus petite valeur du domaine.

indomain(X,Method) Method :

-

- middle

- 3 (un entier )

ex1(X,Y,Z):-

[X,Y,Z]::1:100, X #> Y+10,

Y #> Z + 25, indomain(X).

97?- ex1(X,Y,Z).

X = 38 Y = 27 Z = 1 ? ;

1 call(s) delayed X = 39

Y = Y in [27..28]

Z = Z in [1..2] ? ;

1 call(s) delayed X = 40

Y = Y in [27..29]

Z = Z in [1..3] ?

Exemple

Prédicats de choix

• Assigner une liste de valeur ?

labeling([]).

labeling([H|T]):- indomain(H),

labeling(T).

– Dans quel ordre évaluer les variables ?

– Quelles valeurs tester ?

Prédicats de choix

labeling(List,Arg,Method,Pred) List : liste des variables ou

termes

Arg : 0 pour liste de variable n° du terme si liste de termes

Method : first_fail, most_constrained,...

Pred : prédicat d ’affectation, généralement indomain mais possibilité de

configuration

Prédicats de choix

• Les heuristiques d’ordre d’affectation :

first_fail variable de plus petit

domaine, théoriquement plus rapide (petit arbre de recherche)

most_contrained comme

first_fail mais si conflit, préférer la variable intervenant le plsu souvent dans les contraintes, solution performante.

Prédicats de choix

smallest variable ayant la plus petite

valeur de son domaine : économiser de la mémoire.

largest inverse de smallest ? (utilisé si l’on connaît une valeur max possible) max_regret variable ayant la plus grande

différence entre la plus petite et la 2^ème plus petite valeur de son domaine. Pour des

variables de type cout, ce critère est une bonne mesure du « travail » qu’il reste à faire (convergence) .

Exemple

top(L,N):-

length(L,N), L::1..N,

alldifferent(L),

labeling(L,0,first_fail, indomain).

99?- top(L,7).

L = [1, 2, 3, 4, 5, 6, 7] ? ; L = [1, 2, 3, 4, 5, 7, 6] ? ; L = [1, 2, 3, 4, 6, 5, 7] ? ; L = [1, 2, 3, 4, 6, 7, 5] ? ...

Prédicats d ’opimisation

• Recherche la meilleur solution

• Recherche rapide (un findall est exclu)

min_max(Goal, C)

Goal : prédicat à satisfaire C : liste de couts

minimise la valeur de C.

Prédicats d ’optimisation

• Accélérer la recherche :

min_max(Coal, C, Lower, Upper)

Une solution inférieure à lower peut être considérée optimale.

Une solution supérieure à Upper ne peut l ’être. min_max(Coal, C, Lower, Upper,

Percent)

fixe un pourcentage Percent minimum entre deux solutions qui se suivent dans la recherche.

min_max(Coal, C, Lower, Upper, Percent, Timeout)

la recherche s ’arrête après Timeout secondes

Exemple

top :-

X::1..10, Y::1..10, X+2 #< Y,

min_max(labeling([X,Y],0,first_fai l,indomain),X+Y).

108?- top.

THE SOLUTION IS

labeling([1, 4], 0, first_fail, indomain)

ITS COST IS 5

min_max -> proven optimality

travel(Cities, Costs) :-

Cities=[X1,X2,X3,X4,X5,X6,X7], Costs = [C1,C2,C3,C4,C5,C6,C7], Cities::1..7,

element(X1,[0,205,377,581,461,878,345], C1), element(X2,[205,0,882,427,390,1105,540], C2), element(X3,[677,882,0,619,316,201,470], C3), element(X4,[581,427,619,0,412,592,570], C4), element(X5,[461,390,316,412,0,517,190], C5), element(X6,[878,1105,201,592,517,0,69], C6), element(X7,[345,540,470,570,190,691,0], C7), circuit(Cities),

min_max(labeling(Costs,0,max_regret,indomain),C 1+C2+C3+C4+C5+C6+C7).

• Xi sera la ième ville visitée

• Ci représente le coût pour aller de la ville i a i+1.

Exemple : pour aller de la ville 2 à la ville 3 ça coute 882

Exemple

29?- travel(Citees,Cout).

THE SOLUTION IS

labeling([377, 205, 201, 427, 412, 69, 190], 0 ITS COST IS 1881

--- min_max -> proven optimality

Citees = [3, 1, 6, 2, 4, 7, 5]

Cout = [377, 205, 201, 427, 412, 69, 190] ? ; no (more) solutions

1 3

6 7 5

4 2

377 201

69

412 190 427

205

domaines

diffn(+ListOfRectangle)

– Les rectangles ne doivent pas se chevaucher.

– Leur position et leur taille sont des domaines

diffn([[1,1],[3,2],[5,3]]).

– « Rectangles » à n-dimension (hypercubes) – contraintes sur les volumes, les distances,

les régions :

diffn(+Rectangles, +Min_volume, +Max_volume, +End, +Distances, +Regions)

1 2 3 4 5 6 7 8

début taille

Diffn Exemple

%top : caser 4 bouts (2 de longueur 3, 1 de longueur 10 et 1 de longueur 15

top:-

wflags(64),

[X1,X2,X3,X4]::0..500, D1 = 3, D2=10, D3=15,

diffn([[X1,D1],[X2,D2],[X3,D3],[X4,D1]

]),

%min_max(labeling(LX,0,first_fail,indo main), Nombre),

labeling([X1,X2,X3,X4],0,first_fail,in domain),

write([X1,X2,X3,X4]).

%8?- top.

%[0, 3, 13, 28]

%yes

Diffn Exemple

%top2: caser 4 rectangles (hauteur 10 et longueur 5)

top2:-

wflags(64),

[X1,Y1,X2,Y2,X3,Y3,X4,Y4] ::0..500, Longueur=5,

Hauteur=10,

diffn([[X1,Y1,Longueur,Hauteur],[X2,Y2,Long ueur,Hauteur],[X3,Y3,Longueur,Hauteur],[X4, Y4,Longueur,Hauteur]]),

%min_max(labeling(LX,0,first_fail,indomain) , Nombre),

labeling([X1,Y1,X2,Y2,X3,Y3,X4,Y4],0,first_

fail,indomain),

write([X1,Y1,X2,Y2,X3,Y3,X4,Y4]).

%18?- top2.

%[0, 0, 0, 10, 0, 20, 0, 30]

%yes

Diffn exemple

%top4 : j'ai NbBaguette de bois, dans quelle baguette je decoupe quel bout ?

% on prend un top 3 pour lequel les morceaux ont une Hauteur de 1 et

% HauteurPlaque = NbBaguettes, Yi sera le numero de la baguette dans laquelle

% on decoupe de ieme morceau top4:-

wflags(64),

[X1,Y1,X2,Y2,X3,Y3,X4,Y4] ::0..500, Longueur=5,

Hauteur=1,

NbBaguettes=20,LongueurBaguette=12,

diffn([[X1,Y1,Longueur,Hauteur],[X2,Y2,Longueur,Hauteur], [X3,Y3,Longueur,Hauteur],[X4,Y4,Longueur,Hauteur]],unused ,unused,[LongueurBaguette,NbBaguettes]),

%min_max(labeling(LX,0,first_fail,indomain), Nombre), labeling([X1,Y1,X2,Y2,X3,Y3,X4,Y4],0,first_fail,indomain) ,

write([X1,Y1,X2,Y2,X3,Y3,X4,Y4]).

%30?- top4.

%[0, 0, 0, 1, 0, 2, 7, 19]

%yes

Domaines

• Contraintes cumulatives

– entre ensembles de domaines – basée sur un élément : tache

– répartitions (temporelle, 2D, 3D)

– 20 méthodes de résolutions conjointes

cumulative(Starts, Duration,

Resources, Ends, Surfaces, High, End, Intermediate, Interruption).

Exemple de tâche i

(souvent t) Taux d ’utilisation

Si Ei

Hi

Contraintes globales sur Domaines

• Exemple d ’utilisation simplifiée :

Si, Di et Ri sont des domaines à définir.

cumulative([S1,S2,…Sn],

[D1,D2,…,Dn], [R1,R2,…,Rn],

unused, unused, Limit, End, unused unused).

A tout instant Σ Ri ≤ Limit

Limit

End

• Contraintes de précédence – precedence/5

– cumulative + #<=

• Contraintes de cycle

– cycle/2 à cycle/12 – exemple

49?- length(L,3), L::1..10, cycle(2,L), labeling(L,0,first_fail,indomain).

L = [1, 3, 2] ? ; L = [2, 1, 3] ? ; L = [3, 2, 1] ? ; no (more) solutions

Domaines

1 3 2

1 3

2

cycle(2,L)

Contraintes globales sur domaines

Among/5

Nombre d ’occurrence de valeur dans une suite de domaines :

[X1,X2,X3, X4,X5]::1..4, K::1..5,

among([1,2,K],[X1,X2,X3,X4,X5],[0,0 ,0,0,0],[[1,2],[3],[1,3,4]],all),

1 ou 2 apparaissent 1 fois 3 apparaît 2 fois

1,3,4 apparaissent entre 1 et 5 fois

les domaines

• Utilisation de among

top:-

[X1,X2,X3, X4,X5]::1..4, K::1..5,

among([1,2,K],[X1,X2,X3,X4,X5],[0, 0,0,0,0],[[1,2],[3],[1,3,4]],all), labeling([X1,X2,X3,X4,X5],0,most_c onstrained,indomain),

writeln([X1,X2,X3,X4,X5]).

94?- top.

[1, 3, 3, 4, 4]

Prédicats d ’information sur les domaines

dom(X,L)

top(L):-

X1::1..4, X1#\=2,

dom(X1,L).

37?- top(L).

L = [1, 3, 4] ?

39?- X::1..4, indomain(X), dom(X,L).

X = 1

L = [1] ? ; X = 2

L = [2] ? ;

sur les domaines

domain_info(X,Min,Max,Size,Occ urrence,Active)

43?- X::1..4, X#\=3,

domain_info(X,Mn,Mx,S,NbO,NbA).

X = X in {1..2,4}

Mn = 1 Mx = 4 S = 3

NbO = 0 %nb de contraintes où X est utilisée NbA = 0 ? %nb contraintes utilisant X non

résolues

sur les domaines

46?- X::1..4, Y::2..6, X#\=3, X#>=Y, domain_info(X,Mn,Mx,S,NbO,NbA).

1 call(s) delayed X = X in {2,4}

Y = Y in {2..4}

Mn = 2 Mx = 4 S = 2 NbO = 1 NbA = 1 ?

47?- X::1..4, Y::2..6, X#\=3, X#>=Y,

indomain(Y), domain_info(X,Mn,Mx,S,NbO,NbA).

X = X in {2,4}

Y = 2 Mn = 2 Mx = 4 S = 2 NbO = 1 NbA = 0 ?

Prédicats d ’information

is_in_dom(X,V).

Réussi si la valeur V se trouve dans le domaine X

pc(Term).

Affiche toutes les contraintes actives sur toutes les variables du terme Term

Méthodes de recherche partielles

• Propagation conditionelle

If Cond then Pred1 else Pred2

Cond doit etre satisfait pour toutes les valeurs des domaines concernés.

• Démons de mise à jour

touched(Callback, Var, Info, Type) le prédicat Callback(Var,Info) sera appelé

lorsque la condition Type sera satisfaite

(souvent utilisé avec la bibliothèque graphique XGIP)

Contraintes Rationnelles

• Les variables sont continues (nombre infini de valeurs)

• Résolution type simplex, Gauss

• Domaine d ’application

– Problèmes mathématiques

– Problèmes financiers (analyse d ’emprunt)

– utilisé de façon complémentaire aux contraintes sur domaines

Définition de variables rationnelles

• Nombre rationnel = rapport de deux entiers a/b

• Variable rationnelle :

– toute variable utilisée dans une contrainte rationnelle est une variable rationnelle.

– Déclaration explicite : positive(X)

allpositive(List).

Termes rationnels

• Entier ou nombre rationnel

• Variable rationnelle

• t1+t2, t1-t2 (ti sont des termes)

• -t (t est un terme)

• c*t, t*c, t/c (t : terme, c : nombre

entier ou rationnel)

Tests de type

rational(X)

réussit si X est un nombre rationnel

rvar(X)

réussit si X est une variable rationnelle

pvar(X)

réussit si X est une variable rationnelle positive

rlinear(X)

réussit si X est un term rationnel linéaire

arithmétiques sur les rationnels

X, Y : termes rationnels

X^=Y X^>=Y X^<=Y X^>Y X^<Y

power(X,Pow,Y)(Pow : entier)

ne permet pas le calcul des racines nième (pas des rationnels)

sqrt(X,Y)

Optimisation pour termes rationnels

rmax(X)

utilisation du simplex pour trouver la valeur maximum de X

rmin(X)

valeur minimum de X

rmax2(X,Limit)

Limit est unifiée à la valeur maximum de X, X n ’est pas unifiée.

Exemple

top(L, Objective):- L=[X1, X2, X3], allpositive(L),

2*X1 + 6*X2 + 3*X3 ^<=8, 5*X1 + 4*X2 + 4*X3 ^<=7, 6*X1+ X2 + X3 ^<=12,

Objective ^= 3*X1 + 5*X2 +4*X3, rmax(Objective).

?- top(L, O).

L=[0,(11/12),(5/6)]

O=(95/12)

Regrouper plusieurs contraintes

• But : optimiser la résolution

linear_block(List)

top(L, Objective):- L=[X, X2, X3], linear_block([

allpositive(L),

2*X1 + 6*X2 + 3*X3 ^<=8, 5*X1 + 4*X2 + 4*X3 ^<=7, 6*X1+ X2 + X3 ^<=12,

Objective ^= 3*X1 + 5*X2 +4*X3,]),

rmax(Objective), writeln(L),

writeln([objective, Objective]).

entières

• Plus rapide que les domaines, mais moins de type de contraintes

cutting(?Obj, +List, -Ncuts,+Time) Obj : terme rationnel à optimiser

List : liste de variables

Ncuts : nombre de contraintes supplémentaires générées

Time: entier non utilisé

Trouver les solutions entières

top(L,Objective):-

L=[X1, X2, X3], allpositive(L),

2*X1 + 6*X2 + 3*X3 ^<= 8, 5*X1 + 4*X2 + 4*X3 ^<= 7, 6*X1 + X2 + X3 ^<=12,

Objective ^= 3*X1+5*X2+4*X3,

cutting(Objective, L, Ncuts, _), rmax(Objective),

writeln([ncuts, Ncuts]).

?- top(L,O).

[ncuts,4]

L=[0,1,0]

O=5

variables paramétriques

top:-

allpositive([X1,X2]), X1 + 3*X2 ^<=10,

X1 + X2 ^>=2,

-X1 + 9*X2 ^<= 11,

cutting(-3*X1 + 4*X2, [X1,X2],Ncuts,no), Z^= -3*X1 + 4*X2,

writeln([x1,X1,x2,X2,z,Z]).

29?- top.

[x1, 1 + (1/7)*Pvar$ + (6/7)*Pvar$, x2, 1 - (1/7)*Pvar$ + (1/7)*Pvar$, z, 1 -Pvar$ - 2*Pvar$]

top2:-

allpositive([X1,X2]), X1 + 3*X2 ^<=10,

X1 + X2 ^>=2,

-X1 + 9*X2 ^<= 11,

cutting(-3*X1 + 4*X2, [X1,X2],Ncuts,no), Z^= -3*X1 + 4*X2,

parametric_term([X1,X2],Sum),writeln([sum,Sum], Sum^=0,

writeln([x1,X1,x2,X2,z,Z]).

36?- top2.

[sum, Pvar$ + (Pvar$ + 0)]

[x1, 1, x2, 1, z, 1]

Arrondis, conversions...

fraction(X,Y)

Y est un entier correspondant à la partie fractionnaire de X.

rounddown/2 roundup/2

rat_is_integer/1

réussit si l ’argument est un entier.

rat_maximum(List, X)

X est le plus grand rationnel de la liste List.

rat_minimum(List, X)

linear_to_list/2

93?- L=[X1,X2,X3], allpositive(L),2*X1 +6*X2 + 3*X3 ^<=8, O^=3*X1+5*X2,

linear_to_list(O,J).

L = [X1$, X2$, X3$]

X1 = X1$

X2 = X2$

X3 = X3$

O = 5*X2$ + 3*X1$

J = [0, 5, X2$, 3, X1$] ? ;

linear_length/2

94?- L=[X1,X2,X3],allpositive(L),2*X1 +6*X2 + 3*X3 ^<=8, O^=3*X1+5*X2,linear_length(O,J).

L = [X1$, X2$, X3$]

X1 = X1$

X2 = X2$

X3 = X3$

O = 5*X2$ + 3*X1$

J = 2 ?

conversions

parametric_vars

101?- L=[X1,X2,X3], allpositive(L),2*X1 +6*X2 + 3*X3 ^=8, parametric_vars([X1,X2,X3],J).

L = [X1$, X2$, (8/3) - 2*X2$ - (2/3)*X1$]

X1 = X1$

X2 = X2$

X3 = (8/3) - 2*X2$ - (2/3)*X1$

J = [X1$, X2$] ?

parametric_term

102?- L=[X1,X2,X3],allpositive(L),2*X1 +6*X2 + 3*X3 ^=8,

parametric_term([X1,X2,X3],J).

L = [X1$, X2$, (8/3) - 2*X2$ - (2/3)*X1$]

X1 = X1$

X2 = X2$

X3 = (8/3) - 2*X2$ - (2/3)*X1$

J = X1$ + (X2$ + 0) ?

dans ce cours

• Tout ce qui est dans prolog (est aussi dans chip).

• retardement de propagation

• gestion de fichiers.

• gestions graphiques.

• Débuger (textuel, graphique)

• interface C, SQL.

• gestion de classes !!

La solution des entrepôts

• xij = fraction de la demande du client j provenant de l ’entrepôt i.

• yi = 1 si il y a un entrepôt à l ’emplacement i (0 sinon)

• Contraintes :

– minimiser y = Σ^{fiyi +} ΣΣ^cijxij

– en respectant Σ^{djxij ≤} Miyi, i=1,……,m – et Σ^xij=1, j = 1, ……..,n

– ainsi que yi = 0 ou 1; 0 ≤xi≤ 1

i=1 j=1 m n

j=

1 n

i=1 m

Bibliographie

• Cohen J. (1990) Constraint logic programming

languages. Communication of the ACM, Vol. 33, n°7, July 1990, P. 52-68.

• Colmeraurer A. (1990) An introduction to Prolog III.

Communication of the ACM, Vol 33, n°7, July 1990, p.

71-90.

• Cras J.-Y. (1993) A review of industrial constraint solving tools (1993).

• Fron A. (1994) Programmation par contraintes. Addison- Wesley - 1994.

• Hentenryck P.V. (1989) Constraint satisfac tion in logic programming. MIT Press - 1989.

• ILOG (1999) ILOG Solver : reference manual 4.4. ILOG -- 1999.

• CHIP, System Documentation, (3 tomes), 1996.

• Laurière J.-L. (1978) A Language and a program for stating and solving combinatorial problems. Artificial Intelligence, Vol 10, n°1, 1978, p. 29-127.

• Fages F. (1996) Programmation Logique par contraintes, Edition Ellipses.