2010 - Magma

Examen de Planification Automatique
et Techniques d’Intelligence Artificielle
(PATIA)
Durée : 3h – Aucun document autorisé.
11 mai 2010
1
1.1
Représentation d’un problème de planification
avec la notation Strips
Le loup, la chèvre et le choux
Dans le problème du "loup, la chèvre et le choux", il s’agit de faire passer
ces trois éléments de la rive gauche à la rive droite d’une rivière. Pour cela, on
dispose d’une barque pouvant embarquer à chaque passage au plus un élément.
Sachant que le loup mange la chèvre et que la chèvre mange le choux, résoudre
ce problème consiste à trouver l’ordre dans lequel on doit les faire passer afin
qu’à aucun moment ni la chèvre ni le choux ne soient mis en danger.
Un plan solution est constitué des actions suivantes :
1. Faire traverser la chèvre de gauche à droite,
2. Revenir sur la rive gauche,
3. Faire traverser le choux,
4. Embarquer la chèvre,
5. Revenir sur la rive gauche,
6. Débarquer la chèvre,
7. Faire traverser le loup,
8. Revenir sur la rive gauche,
9. Faire traverser la chèvre.
La représention Strips de ce problème est donnée en annexe.
On s’intéresse à présent à une nouvelle version du problème dans laquelle il
s’agit de faire passer de la rive gauche à la rive droite un loup, une chèvre,
un choux, un bâton et du feu. Pour cela, on dispose d’une barque pouvant
embarquer au plus deux éléments à chaque traversée.
1
a) Sachant que le feu brûle le bâton, le bâton bat le loup, le loup mange la
chèvre et la chèvre mange le choux, donnez un plan informel pour résoudre
ce problème,
b) Donnez la représentation Strips de cette nouvelle version.
1.2
Monkey-and-bananas
Dans le problème "Monkey-and-bananas", un singe est enfermé dans une
cage dans laquelle sont suspendues des bananes. Le singe dispose d’une caisse
lui permettant d’attraper les bananes lorsqu’il monte dessus. Initialement, le
singe est dans la position A, les bananes sont en B et la caisse est en C. Le singe
est Low lorsqu’il est sur le sol et High lorsqu’il est sur la caisse. Les bananes
sont High et la caisse est Low. Les actions que le singe peut effectuer sont les
suivantes : Go pour aller d’un endroit à l’autre, Push pour pousser un objet
qu’on tient d’un endroit à l’autre, ClimbUp et ClimbDown pour monter ou
descendre d’un objet puis Grasp et UnGrasp pour attraper ou lacher un objet.
Son but est d’attraper les bananes.
a) Représentez en Strips l’état initial et le but de ce problème,
b) Représentez en Strips les six actions.
2
Planification SAT
L’une des techniques de planification consiste à représenter un problème par
une formule SAT en forme normale conjonctive.
a) Donnez l’algorithme de Davis & Putnam,
b) Donnez de façon informelle les cinq types d’axiomes devant être vérifiés par
la formule SAT. Expliquez.
3
Graphe de planification
Soit le domaine de planification suivant :
Actions
Préconditions
Ajouts
Retraits
OPa
{a}
{c}
{d}
OPb
{b}
{d}
{}
OPc
{c}
{e}
{}
OPd
{d}
{e}
{}
a) L’état initial est s0 = {a, b}. Faire le graphe de planification jusqu’à P2 (P0,
A1, P1, A2, P2),
b) Indiquez quelles sont les actions et les propositions en exclusion mutuelle.
Expliquez.
2
Annexe
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
(loup OBJECT)
(chevre OBJECT)
(choux OBJECT)
(left PLACE)
(right PLACE)
(preconds
(at left chevre)
(at left loup)
(at left choux)
(at left boat)
(eat loup chevre)
(eat chevre choux)
(safe choux)
(safe chevre)
(boat_empty)
)
(effects
(at right chevre)
(at right loup)
(at right choux)
)
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
(operator
LOAD
(params
(<x> OBJECT)
(<from> PLACE))
(preconds
(at <from> <x>)
(at <from> boat)
(boat_empty))
(effects
(at on_board <x>)
(del at <from> <x>)
(del boat_empty))
)
(operator
UNLOAD
(params
(<x> OBJECT)
(<to> PLACE))
(preconds
(at on_board <x>)
(at <to> boat))
(effects
(boat_empty)
(at <to> <x>)
(del at on_board <x>))
)
(operator
MOVE
(params
(<from> PLACE)
(<to> PLACE))
(preconds
(at <from> boat)
(safe chevre)
(safe choux))
(effects
(at <to> boat)
(del at <from> boat)
(del safe chevre)
(del safe choux))
)
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
(operator
SAFE
(params
(<here> PLACE)
(<there> PLACE)
(<x> OBJECT)
(<y> OBJECT))
(preconds
(at <here> <x>)
(at <there> <y>)
(eat <x> <y>))
(effects
(safe <y>))
)
(operator
SAFE
(params
(<here> PLACE)
(<x> OBJECT)
(<y> OBJECT))
(preconds
(at <here> <x>)
(at on_board <y>)
(eat <x> <y>))
(effects
(safe <y>))
)
5
Eléments de solution
3.1
3.1.1
Représentation d’un problème de planification avec la
notation Strips
Le loup, la chèvre et le choux
a) Voici un plan solution :
1. Embarquer la chèvre et le baton,
2. Se rendre sur la rive droite,
3. Débarquer la chèvre et le bâton,
4. Revenir sur la rive gauche
5. Embaquer le feux et le choux,
6. Se rendre sur la rive droite,
7. Débarquer le feu et le choux,
8. Embarquer le bâton et la chèvre,
9. Revenir sur la rive gauche,
10. Débarquer le bâton et la chèvre,
11. Embarquer le loup,
12. Revenir sur la rive droite,
13. Débarquer le loup,
14. Revenir sur la rive gauche,
15. Embarquer la chèvre et le bâton,
16. Se rendre sur la rive droite,
17. Débarquer la chèvre et le bâton.
b) Voir les algorithmes 6 à 9.
3.1.2
Monkey-and-bananas
Voir les algorithmes 10 à 13.
3.2
Planification SAT
a) Voir les algorithmes 1 et 2.
b) Il s’agit d’un plan par étapes. Les axiomes indiquent des propriétés devant
être vérifiées à une étape donnée du plan.
– Etat initial :
^
s0 ∧ {
¬f }
f ∈s
/ 0
– But :
g∧{
^
f ∈g
/
6
¬f }
– Actions :
^
^
^
ai → { precond(ai )} ∧ { effect+ (ai )} ∧ { ¬effect− (ai )}
– Transitions d’états :
¬fi ∧ fi+1 → {
_
ai }
fi+1 ∈effect+ (ai )
fi ∧ ¬fi+1 → {
_
ai }
fi+1 ∈effect− (ai )
– Actions exclusives
¬ai ∨ ¬bi
Algorithm 1: unitPropagate(Γ,x)
1
2
3
4
5
6
7
8
9
10
11
12
if isEmpty(Γ) then
return [];
else
c ← getFirst(Γ);
Γ ← Γ − {c};
if contains(c,x) then
return unitPropagate(Γ,x);
else
if contains(c,−x) then
return remove(−x,c) · unitPropagate(Γ,x);
else
return c · unitPropagate(Γ,x);
3.3
Graphe de planification
a) Voir le graphique Fig. 1,
b) OPa et OPb sont mutex car elles ne sont pas indépendantes : OPa retire l’un
des effets de OPb. c et d sont mutex car toutes les actions qui les produisent
sont mutex. OPc et OPd sont mutex car leurs préconditions sont mutex.
7
Algorithm 2: DP(Γ, µ)
1
2
3
4
5
6
7
8
9
10
11
12
if isEmpty(Γ) then
return [];
else
if contains(Γ, []) then
return [];
else
x ← getFirst(getFirst(Γ));
// A basic strategy
µ0 ← DP(unitPropagate(Γ,x), add(x, µ));
if isEmpty(µ0 ) then
return DP(unitPropagate(Γ,−x), add(−x, µ));
else
return µ0 ;
OPa
a
b
OPc
c
d
OPb
P0
A1
e
OPd
P1
A2
Fig. 1 – Graphe de planification
8
P2
Algorithm 3:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
(loup OBJECT)
(chevre OBJECT)
(choux OBJECT)
(feu OBJECT)
(baton OBJECT)
(one SLOT)
(two SLOT)
(left PLACE)
(right PLACE)
(preconds
(at left chevre)
(at left loup)
(at left choux)
(at left baton)
(at left feu)
(at left boat)
(eat feu baton)
(eat baton loup)
(eat loup chevre)
(eat chevre choux)
(safe feu)
(safe baton)
(safe loup)
(safe choux)
(safe chevre)
(boat_slot one empty)
(boat_slot two empty)
)
(effects
(at right baton)
(at right feu)
(at right chevre)
(at right loup)
(at right choux)
)
9
Algorithm 4:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
(operator
LOAD
(params
(<x> OBJECT)
(<from> PLACE)
(<slot> SLOT))
(preconds
(at <from> <x>)
(at <from> boat)
(boat_slot <slot> empty))
(effects
(boat_slot <slot> <x>)
(del at <from> <x>)
(del boat_slot <slot> empty))
)
(operator
UNLOAD
(params
(<x> OBJECT)
(<to> PLACE)
(<slot> SLOT))
(preconds
(boat_slot <slot> <x>)
(at <to> boat)
)
(effects
(boat_slot <slot> empty)
(at <to> <x>)
(del boat_slot <slot> <x>))
)
10
Algorithm 5:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
(operator
MOVE
(params
(<from> PLACE)
(<to> PLACE))
(preconds
(at <from> boat)
(safe baton)
(safe loup)
(safe chevre)
(safe choux))
(effects
(at <to> boat)
(del at <from> boat)
(del safe baton)
(del safe loup)
(del safe chevre)
(del safe choux))
)
(operator
SAFE
(params
(<here> PLACE)
(<there> PLACE)
(<x> OBJECT)
(<y> OBJECT))
(preconds
(at <here> <x>)
(at <there> <y>)
(eat <x> <y>))
(effects
(safe <y>))
)
11
Algorithm 6:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
(operator
SAFE
(params
(<here> PLACE)
(<x> OBJECT)
(<y> OBJECT)
(<slot> SLOT))
(preconds
(at <here> <x>)
(boat_slot <slot> <y>)
(eat <x> <y>))
(effects
(safe <y>))
)
Algorithm 7:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(bananas OBJECT)
(monkey AGENT)
(box OBJECT)
(A PLACE)
(B PLACE)
(C PLACE)
(low POSITION)
(high POSITION)
(preconds
(at A monkey)
(at B bananas)
(at C box)
(position monkey low)
(position box low)
(position bananas high)
(arm-empty monkey)
(free box)
(free bananas)
(climbable box)
)
(effects
(holding monkey bananas)
)
12
Algorithm 8:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
(operator
GO
(params
(<x> AGENT)
(<from> PLACE)
(<to> PLACE))
(preconds
(at <from> <x>)
(position <x> low))
(effects
(at <to> <x>)
(del at <from> <x>))
)
(operator
PUSH
(params
(<x> AGENT)
(<y> OBJECT)
(<from> PLACE)
(<to> PLACE))
(preconds
(at <from> <x>)
(at <from> <y>)
(position <x> low)
(position <y> low)
(holding <x> <y>)
)
(effects
(at <to> <x>)
(at <to> <y>)
(del at <from> <x>)
(del at <from> <y>))
)
13
Algorithm 9:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
(operator
GRASP
(params
(<x> AGENT)
(<y> OBJECT)
(<from> PLACE)
(<pos> POSITION))
(preconds
(at <from> <x>)
(at <from> <y>)
(position <x> <pos>)
(position <y> <pos>)
(arm-empty <x>)
(free <y>))
(effects
(holding <x> <y>)
(del free <y>)
(del arm-empty <x>))
)
(operator
UNGRASP
(params
(<x> AGENT)
(<y> OBJECT)
(<from> PLACE)
(<pos> POSITION))
(preconds
(at <from> <x>)
(at <from> <y>)
(position <x> <pos>)
(position <y> <pos>)
(holding <x> <y>))
(effects
(del holding <x> <y>)
(arm-empty <x>)
(free <y>))
)
14
Algorithm 10:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
(operator
CLIMB_UP
(params
(<x> AGENT)
(<y> OBJECT)
(<from> PLACE))
(preconds
(at <from> <x>)
(at <from> <y>)
(position <x> low)
(position <y> low)
(climbable <y>))
(effects
(position <x> high)
(del position <x> low))
)
(operator
CLIMB_DOWN
(params
(<x> AGENT)
(<y> OBJECT)
(<from> PLACE))
(preconds
(at <from> <x>)
(at <from> <y>)
(position <x> high)
(position <y> low)
(climbable <y>))
(effects
(position <x> low)
(del position <x> high))
)
15