Modularité pour les programmes de robots

Transparents en français pour ma soutenance de stage de Master 1 (M1) en 2013.
Travail sous la direction de J.Villard et P.O'Hearn.
Stage de 3 mois au laboratoire d'informatique, équipe PPLV, à l'University College of London (UK).

Transcript

1. Modularité pour les programmes de robots Soutenance de Stage de M1 – Informatique Lilian Besson ENS Cachan Département d’Informatique Jeudi 5 Septembre 2013 Lilian.BESSON@ens-cachan.fr http://www.dptinfo.ens-cachan.fr/~lbesson/stageM1/
2. Présentation Contexte Contexte humain Quand? 10 semaines, 03 Juin Ñ 09 Août. Où? À Londres, Royaume-Uni : UCL University College London, PPLV groupe “Logique, Vérification, et Principes des langages de Programmation”. Avec qui? Jules Villard, Peter O’Hearn. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 1 / 23
3. Présentation Contexte Deux domaines Intelligence Artificielle : domaine très large (I.A.) Aujourd’hui, seulement de la planification : modéliser un monde dynamique, trouver des trajectoires dans ce monde. Vérification (domaine de l’équipe PPLV ) Prouver une spécification d’un programme. Exemple : f pxq def  x : x 1 : Effets de f précondition x  0 et postcondition x  1 : tx  0u x : x 1 tx  1u Non-effets de f si y $ x, y  2 est conservé : tx  0 ”y  2u x : x 1 tx  1 ”y  2u Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 2 / 23
4. Présentation Problématiques Problématiques et buts Différentes composantes : décrire une axiomatisation calcul des situations, programmer une fonction langage GOLOG, prouver cette fonction système de preuve HG. Pourquoi vouloir être modulaire ? efficacité (passage à l’échelle), élégance, et simplicité ! Différentes modularité : décrire une axiomatisation la changer facilement après, programmer une fonction intermédiaire, la spécifier, puis l’utiliser sans connaître son implémentation, prouver cette fonction une seule fois, puis utiliser sa spécification partout ailleurs comme un axiome (sans le reprouver). Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 3 / 23
5. Présentation Problématiques Problématiques et buts Différentes composantes : décrire une axiomatisation calcul des situations, programmer une fonction langage GOLOG, prouver cette fonction système de preuve HG. Pourquoi vouloir être modulaire ? efficacité (passage à l’échelle), élégance, et simplicité ! Différentes modularité : décrire une axiomatisation la changer facilement après, programmer une fonction intermédiaire, la spécifier, puis l’utiliser sans connaître son implémentation, prouver cette fonction une seule fois, puis utiliser sa spécification partout ailleurs comme un axiome (sans le reprouver). Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 3 / 23
6. Planification Un modèle connu Graphes = modèle de système dynamique Exemple: un graph dirigé, def  tA, B, C u, tA B, B C u Recherche de chemin Choisir u, v dans . Y a-t-il un chemin u  v ? Deux réponses possibles : Oui A  C ? Oui, A B C. Non B  A ? Non. A B C Figure 1: Le graphe . Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 4 / 23
7. Planification Un modèle connu Graphes = modèle de système dynamique Exemple: un graph dirigé, def  tA, B, C u, tA B, B C u Recherche de chemin Choisir u, v dans . Y a-t-il un chemin u  v ? Deux réponses possibles : Oui A  C ? Oui, A B C. Non B  A ? Non. A B C Figure 1: Le graphe . Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 4 / 23
8. Planification I.A. : modéliser des mondes qui évoluent Monde dynamique  un graphe Jeu d’échec (Exemple) Un énorme graphe fini. ÝÑ Trop grand pour utiliser la théorie des graphes. sommet ðñ une “photo” du système  un état, arrête ðñ transformation sur le système  une action. Monde des blocs (Exemple) Blocs posés sur le sol – un robot pour les déplacer. En pratique : trop d’états différents ! Graphe : pas utilisable, même pour des mondes “simples” en I.A. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 5 / 23
9. Planification I.A. : modéliser des mondes qui évoluent Monde dynamique  un graphe Jeu d’échec (Exemple) Un énorme graphe fini. ÝÑ Trop grand pour utiliser la théorie des graphes. sommet ðñ une “photo” du système  un état, arrête ðñ transformation sur le système  une action. Monde des blocs (Exemple) Blocs posés sur le sol – un robot pour les déplacer. En pratique : trop d’états différents ! Graphe : pas utilisable, même pour des mondes “simples” en I.A. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 5 / 23
10. Monde des blocs Calcul des situations Aperçu États (Exemples) objets x, y, A fluents F, ParTerre ÝÑ formules logiques F px, yq, ParTerre pA q Transformations (Exemples) actions : a, BougeSur, BougeSol ÝÑ triplets de Liu tQu a tRu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 6 / 23
11. Monde des blocs Description statique (1/2) État initial Figure 2: 3 blocs A, B et C sur le sol Différents genres d’éléments objets A, B, C prédicats Libre pxq, ParTerre pxq et . . . État initial Γ0 def  Libre(A) ”ParTerre(A) ” Libre(B) ”ParTerre(B) ” Libre(C) ”ParTerre(C) Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 7 / 23
12. Monde des blocs Description statique (2/2) Destination  état but Figure 3: Une tour: A sur B sur C Différents genres d’éléments objets A, B, C prédicats Libre pxq, ParTerre pxq et Sur px, yq État but Γbut def  Sur(A, B) ”Sur(B, C) Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 7 / 23
13. Monde des blocs Description du dynamisme Actions primitives de GOLOG Déplacer x vers y : BougeSur px, yq tLibre pxq”px $ yq”Libre pyqu BougeSur px, yq tSur px, yqu Déplacer z depuis un certain w vers le sol : BougeSol pzq tLibre pzq”pz $ wq”Sur pz, wqu BougeSol pzq tParTerre pzq”2Sur pz, wq”Libre pwqu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 8 / 23
14. Monde des blocs Description du dynamisme Actions primitives de GOLOG Déplacer x vers y : BougeSur px, yq tLibre pxq”px $ yq”Libre pyqu BougeSur px, yq tSur px, yqu Déplacer z depuis un certain w vers le sol : BougeSol pzq tLibre pzq”pz $ wq”Sur pz, wqu BougeSol pzq tParTerre pzq”2Sur pz, wq”Libre pwqu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 8 / 23
15. Monde des blocs Trajectoires Programme séquentiel = trajectoire Proc f pA, B, C q : BougeSur(B, C) ; BougeSur(A, B) FinProc; Figure 4: État initial Γ0 Situation initiale : historique vide Γ0 def  Libre(A) ”ParTerre(A) ”Libre(B) ”ParTerre(B) ”Libre(C) ”ParTerre(C) Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 9 / 23
16. Monde des blocs Trajectoires Programme séquentiel = trajectoire Proc f pA, B, C q : BougeSur(B, C) looooooooomooooooooon Γ0 Γ1 ; BougeSur(A, B) FinProc; Figure 4: État intermédiaire Γ1 Première action BougeSur(B, C) Γ1 def  Libre(A) ”ParTerre(A) ”Libre(B) ”Sur(B,C) ”ParTerre(C) tLibre pB q”pB $ C q”Libre pC qu BougeSur pB, C q tSur pB, C qu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 9 / 23
17. Monde des blocs Trajectoires Programme séquentiel = trajectoire Proc f pA, B, C q : BougeSur(B, C) ; BougeSur(A, B) looooooooomooooooooon Γ1 Γbut FinProc; Figure 4: Destination Γ2  Γbut Seconde action BougeSur(A, B) Γ2  Γbut def  Libre(A) ”Sur(A, B) ”Sur(B,C) ”ParTerre(C) tLibre pA q”pA $ B q”Libre pB qu BougeSur pA, B q tSur pA, B qu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 9 / 23
18. Programmes GOLOG Correction de BougeND BougeND : implémentation Un programme GOLOG : BougeND px, y, zq pour déplacer x sur y ou sur z. Proc BougeND px, y, zq : BougeSur px, yq | BougeSur px, zq FinProc; Spécification = triplet de Liu : tQu BougeND px, y, zq tRu t Q hkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkikkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkj Libre pxq”px $ yq”Libre pyq”px $ zq”Libre pzqu BougeND px, y, zq tSur px, yq•Sur px, zq loooooooooooomoooooooooooon R u Idée : Si Qrss est vrai, BougeND px, y, zq est applicable et termine en partant de s, alors exécuter BougeND depuis s arriver en s1, avec Rrs1s. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 10 / 23
19. Programmes GOLOG Correction de BougeND BougeND : implémentation et spécification Un programme GOLOG : BougeND px, y, zq pour déplacer x sur y ou sur z. Proc BougeND px, y, zq : BougeSur px, yq | BougeSur px, zq FinProc; Spécification = triplet de Liu : tQu BougeND px, y, zq tRu t Q hkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkikkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkj Libre pxq”px $ yq”Libre pyq”px $ zq”Libre pzqu BougeND px, y, zq tSur px, yq•Sur px, zq loooooooooooomoooooooooooon R u Idée : Si Qrss est vrai, BougeND px, y, zq est applicable et termine en partant de s, alors exécuter BougeND depuis s arriver en s1, avec Rrs1s. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 10 / 23
20. Le système de preuve HG Preuve rapide pour BougeND Proc BougeND px, y, z q : BougeSur px, y q | BougeSur px, z q FinProc Q def  Libre px q^x  y ^Libre py q^x  z ^Libre pz q R def  Sur px, y q _ Sur px, z q pa, b q def  Libre pa q^a  b ^Libre pb q ND Cons axiome tpx, yqu Bge px, yq tSur px, yqu tQu Bge px, yq tRu tpx, zqu Bge px, zq tSur px, zqu axiome tQu Bge px, zq tRu Cons tQu Bge px, yq|Bge px, zq tRu Figure 5: Schéma de preuve pour BougeND pBge def  BougeSur q Règle de choix : (ND) Permet de séparer 1|2 , ND tP u 1 tQ u tP u 2 tQ u tP u 1|2 tQ u Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 11 / 23
21. Le système de preuve HG Preuve rapide pour BougeND Proc BougeND px, y, z q : BougeSur px, y q | BougeSur px, z q FinProc Q def  Libre px q^x  y ^Libre py q^x  z ^Libre pz q R def  Sur px, y q _ Sur px, z q pa, b q def  Libre pa q^a  b ^Libre pb q ND Cons axiome tpx, yqu Bge px, yq tSur px, yqu tQu Bge px, yq tRu tpx, zqu Bge px, zq tSur px, zqu axiome tQu Bge px, zq tRu Cons tQu Bge px, yq|Bge px, zq tRu Figure 5: Schéma de preuve pour BougeND pBge def  BougeSur q Règle de conséquence : (Cons) Deux choses: renforce la précondition, affaiblit la postcondition : Cons l Q ñ Q1 ¨ tQ1 u tR1 u l R1 ñ R ¨ tQ u tR u Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 11 / 23
22. Le système de preuve HG Preuve rapide pour BougeND Proc BougeND px, y, z q : BougeSur px, y q | BougeSur px, z q FinProc Q def  Libre px q^x  y ^Libre py q^x  z ^Libre pz q R def  Sur px, y q _ Sur px, z q pa, b q def  Libre pa q^a  b ^Libre pb q ND Cons axiome tpx, yqu Bge px, yq tSur px, yqu tQu Bge px, yq tRu tpx, zqu Bge px, zq tSur px, zqu axiome tQu Bge px, zq tRu Cons tQu Bge px, yq|Bge px, zq tRu Figure 5: Schéma de preuve pour BougeND pBge def  BougeSur q Règle de conséquence : (Cons) Deux choses: renforce la précondition, affaiblit la postcondition : Cons l Q ñ Q1 ¨ tQ1 u tR1 u l R1 ñ R ¨ tQ u tR u Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 11 / 23
23. Le système de preuve HG Preuve rapide pour BougeND Proc BougeND px, y, z q : BougeSur px, y q | BougeSur px, z q FinProc Q def  Libre px q^x  y ^Libre py q^x  z ^Libre pz q R def  Sur px, y q _ Sur px, z q pa, b q def  Libre pa q^a  b ^Libre pb q ND Cons axiome tpx, yqu Bge px, yq tSur px, yqu tQu Bge px, yq tRu tpx, zqu Bge px, zq tSur px, zqu axiome tQu Bge px, zq tRu Cons tQu Bge px, yq|Bge px, zq tRu Figure 5: Schéma de preuve pour BougeND pBge def  BougeSur q Règle de conséquence : (Cons) Deux choses: renforce la précondition, affaiblit la postcondition : Cons l Q ñ Q1 ¨ tQ1 u tR1 u l R1 ñ R ¨ tQ u tR u Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 11 / 23
24. Le système de preuve HG Modularité pour GOLOG et HG Programme BgeOu px, y, z, wq Rappel de BougeND Proc BougeND px, y, z q : BougeSur px, y q | BougeSur px, z q FinProc; BgeOu px, y, z, wq pour déplacer un bloc x sur y ou z, ou w: Proc BgeOu px, y, z, wq : BougeND px, y, zq | BougeSur px, wq FinProc; Spécification pour BgeOu Q1 def  Libre px q^px  y q^Libre py q^px  z q^Libre pz q^px, y, z  w q^Libre pw q tQ1u BgeOu px, y, z, wq tSur px, yq•Sur px, zq•Sur px, wqu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 12 / 23
25. Le système de preuve HG Modularité pour GOLOG et HG Preuve de BgeOu : ok :) On veut prouver tQ1u BgeOu tR1u Q1 def  px, yq”px, zq”y, z $ w ”px, wq R1 def  Sur px, yq • Sur px, zq • Sur px, wq pa, bq def  Libre paq”a $ b ”Libre pbq ND Cons axiome tQu BougeND px, y, zq tRu tQ1u BougeND px, y, zq tR1u tpx, wqu Bge px, wq tSur px, wqu axiome tQ1u Bge px, wq tR1u Cons tQ1u BougeND px, y, zq|Bge px, wq tR1u Figure 6: Schéma de preuvre pour BgeOu. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 13 / 23
26. Le système de preuve HG Modularité pour GOLOG et HG Programme BgeApres px, y, z, wq Rappel de BougeND Proc BougeND px, y, z q : BougeSur px, y q | BougeSur px, z q FinProc; BgeApres px, y, z, wq utiliser BougeND px, y, zq, et puis après déplacer x sur w: Proc BgeApres px, y, z, wq : BougeND px, y, zq ; BougeSur px, wq FinProc; Spécifications pour BgeApres Q1 def  Libre px q^px  y q^Libre py q^px  z q^Libre pz q^px, y, z  w q^Libre pw q tQ1u BgeApres px, y, z, wq tSur px, wqu Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 14 / 23
27. Le système de preuve HG Soucis dans la preuve de BgeApres Preuve de BgeApres : soucis ! (1/2) On veut prouver tQ1 u BgeApres tSur px, w u Q1 def  px, y q^ px, z q^x, y, z  w ^ px, w q Invariant: Inv def  Libre px q^ x, y, z  w ¨ ^Libre pw q pa, b q def  Libre pa q^a  b ^Libre pb q Seq ons ? ? tQND u BougeND px, y, z q tRND u ?!? tQND ^Inv u BougeND px, y, z q tRND ^Inv u tQ1 u BougeND px, y, z q tRND ^Inv u t px, w qu Bge px, w q tSur px, w qu Axm. tRND ^Inv u Bge px, w q tSur px, w qu Con tQ1 u BougeND px, y, z q;Bge px, w q tSur px, w qu Figure 7: Tentative d’un schéma de preuve pour BgeApres. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 15 / 23
28. Le système de preuve HG Soucis dans la preuve de BgeApres Preuve de BgeApres : soucis ! (2/2) BgeApres px, y, z, wq pour déplacer un bloc x sur y ou z, et puis après déplacer x sur w: Proc BgeApres px, y, z, wq : BougeND px, y, zq ; BougeSur px, wq FinProc; BougeND px, y, zq doit conserver Libre pxq”x $ w ”Libre pwq ? ? tQND u BougeND px, y, z q tRND u ?!? tQND ^Inv u BougeND px, y, z q tRND ^Inv u Comment ? En utilisant le corps de MoveND ? ùñ non-modulaire ! Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 16 / 23
29. Le système de preuve HG Diagnostic? Axiomes de HG pour les actions primitives Axiomes de Frame et d’Effets (EF) Réf. [Rei01] F : fluent avec axiome d’état successeur F pÝ Ñ x , FairepA, sqq  ΦF pÝ Ñ x , Aqrss : tΦF pÝ Ñ x1 , ApÝ Ñ x2 qqu ApÝ Ñ x2 q tF pÝ Ñ x1 qu t2ΦF pÝ Ñ x1 , ApÝ Ñ x2 qqu ApÝ Ñ x2 q t2F pÝ Ñ x1 qu Trop d’axiomes EF Il y a en a 2 par fluents F et par actions A ! Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 17 / 23
30. Le système de preuve HG Diagnostic? Source du soucis ? Diagnostic “Axiomes de Frame et d’Effet” tant qu’on n’ajoute pas de nouvelles actions ou procédures, mais programmer en GOLOG = écrire des procédures intermédiaires et les utiliser ailleurs, possible d’actualiser les axiomes (EF), mais on doit prouver 2 ¢Nb.Fluents lemmes par nouvelles procédures ! ÝÑ le système de preuve HG manque de modularité ! Générer les axiomes EF ? En fait, on écrit des “axiomes d’états successeur” : un par fluent, mais de taille linéaire dans le nombre d’actions. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 18 / 23
31. Conclusion et perspectives Résumé Conclusion Nous avons présenté situation c. décrire un monde dynamique, GOLOG écrire des procédures pour ce monde, HG prouver ces procédures. Nous avons dévoilé des limitations pour HG pas de bonne abstraction procédurale ÝÑ pas modulaire ! Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 19 / 23
32. Une approche plus concrète Outils utilisés Approche concrète : formalisme, norme et outils Aussi : STRIPS, PDDL et pyperplan STRIPS autre formalisme, PDDL norme pour STRIPS, développée pour l’IPC, pyperplan solveur pour des problèmes de planification écrits en PDDL, validate outil pour prouver la validité de trajectoires écrites en PDDL. Contributions expériences et tests concrets: ãÑ faiblesses du formalisme, ãÑ faiblesses de ces outils, développer des techniques pour les résoudre. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 20 / 23
33. Une approche plus concrète Outils utilisés Exemple d’expérience avec pyperplan Réf.[Mal11] Limitations concrètes (Exemple) ã Ñ n’utilise pas le fait que certaines parties du monde sont disjointes : perte de performance ! Number of ob- ject Number of world Computation time (in s) Lenght of the plan Optimal plan 4,0,0,0 4 0.137 6 6 4,4,0,0 4 0.277 24 12 4,4,4,0 4 1.213 42 18 4,4,4,4 4 3.486 60 24 Figure 8: Union disjointe de mondes similaires, et un but croissant. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 21 / 23
34. Une approche plus concrète Travaux futurs Quelles perspectives ? Améliorer la compositionalité pour HG trouver un moyen d’avoir un axiome de “frame” générique: Frame tQP u P pxq tRP u “QP Inv” tQP ”Invu P pxq tRP ”Invu Implémentation ? Mise en pratique de ces idées ? GOLOG ajouter procédures GOLOG à un planning solver (pyperplan), HG ajouter HG à un planning verifier (validate). Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 22 / 23
35. Une approche plus concrète Merci Merci d’avoir écouté ! Des questions ? Pour en savoir plus ? ã Ñ lire mon rapport, disponible en ligne ici : http://www.dptinfo.ens-cachan.fr/~lbesson/rapportM1Info13.pdf ã Ñ utiliser la bibliographie. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 23 / 23
36. Annexe Bibliographie Bibliographie Richard Fikes and Nils Nilsson. [FN72] Strips: A new approach to the application of theorem proving to problem solving. Artificial intelligence, 2(3):189–208, 1972. Raymond Reiter. [Rei01] Knowledge in Action: Logical Foundations for Specifying and Implementing Dynamical Systems. The MIT Press, 2001. Yangmei Liu. [Liu02] A Hoare-style proof system for robot programs. AAAI, 2002. Herbert Malte. [Mal11] pyperplan, a lightweight STRIPS planner, written in python 3. https://bitbucket.org/malte/pyperplan, 2011. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 23 / 23
37. Annexe Rapide présentation de PDDL Un domaine pour la planification (Annexe) (define (domain BLOCKS) (:requirements :strips :typing) (:types block) (:predicates (On ?x ?y - block) (OnFloor ?x - block) (Clear ?x - block)) (:action Move :parameters (?block1 ?block2 - block) :precondition (and (Clear ?block1) (Clear ?block2) (OnFloor ?block1)) :effect (and (not (Clear ?block2)) (not (OnFloor ?block1)) (On ?block1 ?block2) ) ) (:action PutFloor :parameters (?block1 ?block2 - block) :precondition (and (Clear ?block1) (On ?block1 ?block2)) :effect (and (OnFloor ?block1) (Clear ?block2) (not (On ?block1 ?block2)) ) ) ) Figure 9: Une axiomatisation du monde des blocs en PDDL. Remarque : on doit changer un peu : Move px, yq demande à x d’être sur le sol. Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 23 / 23
38. Annexe Rapide présentation de PDDL Un problème de planification (Annexe) ;;; This goal is reachable, and the solver proves his reachability, by giving a solution (define (problem REACHABLE) (:domain BLOCKS) (:objects A B C - block) (:init (Clear A) (OnFloor A) (Clear B) (OnFloor B) (Clear C) (OnFloor C) ) (:goal (and (On A B) (On B C) ) ) ) ;;; The generated solution is: (Move B C) (Move A B) Figure 10: Axiomatisation un but atteignable Γgoal en PDDL (move b c) (move a b) Figure 11: Une trajectoire trouvée par pyperplan Lilian Besson (ENS Cachan) Soutenance de Stage de M1 – Informatique Jeudi 5 Septembre 2013 23 / 23