PLANEAMENTO E ESCALONAMENTO

UNIVERSIDADE DE COIMBRA FACULDADE DE CIÊNCIAS E TECNOLOGIA

Departamento de Engenharia Informática

Pólo II da Universidade, Pinhal de Marrocos 3030 Coimbra, Portugal

Tel.: 239790000 — Fax: 239701266

PLANEAMENTO E ESCALONAMENTO

ANO LECTIVO DE 1999/00

Parte Prática - Ficha nº 1

Objectivo

: Ambientação com planeador Prodigy 4.0.

Nota prévia:

O planeador Prodigy foi desenvolvido por uma equipa da Carnegie-Mellon

University, USA; a adaptação para Allegro Common Lisp em Windows foi feita por José Luis

Ferreira e Amílcar Cardoso.

Parte I - Arranque

1. Faça logon e localize, na página de cadeira (www.dei.uc.pt/~pe), o link para o Prodigy.

2. Faça download para “c:/users/Prodigy” (crie a directoria se ela não existir ainda).

3. Arranque o Allegro Common Lisp.

4. Carregue (load) o ficheiro “loader.lsp”.

5. Execute a função

(load-compiled)

. Após este passo, está apto(a) a utilizar o Prodigy 4.0

Nota: como a directoria “c:/users” é acessível a qualquer utilizador, aconselha-se a repetir estes

passos no início de cada aula/sessão e a guardar código desenvolvido em lugar seguro.

encontrará uma listagem do ficheiro em causa.

3. Execute o comando

(problem ‘p3)

. Carregará assim uma definição de um problema para o

domínio em causa.

4. Abra o ficheiro “c:/users/Prodigy/Domains/Blocksworld/Probs/p3.lsp” e observe com atenção o

seu conteúdo (na directoria Probs de cada domínio encontram-se diversos problemas definidos).

Em apêndice a este trabalho, encontrará uma listagem do ficheiro em causa.

5. Execute o comando

(run). Observe e analise o resultado.

Parte III - Experimentação 1

1. Na directoria “~/Domains” crie uma directoria “blocks-test” e copie para lá o ficheiro

“domain.lsp” do domínio “blocksworld”.

2. No ficheiro copiado, elimine todas as Control Rules.

3. Crie em seguida um problema com

•

estado inicial:

•

on(B,A), clear(B), clear(C), clear(D), arm-empty, table(A), table(C),

on-table(D)

•

objectivo:

•

on(C,A), on(B,D), on-table(A), on-table(D)

4. Experimente.

Note que este problema é o apresentado no acetato 26 das aulas teóricas.

Parte IV - Experimentação 2

1. Altere agora a definição do domínio anterior de acordo com o exemplo apresentado na Figura 1

do Manual do Prodigy (vai incluir uma regra de inferência e alterar ligeiramente os operadores).

2. Experimente utilizando o problema que definiu anteriormente.

APÊNDICE 1

Definição do domínio “blocksworld”

;;; The control rules in this version are by Manuela, 10/94

(create-problem-space 'blocksworld :current t)

(ptype-of OBJECT :top-type)

(OPERATOR PICK-UP (params <ob1>) (preconds

((<ob1> OBJECT)) (and (clear <ob1>)

(on-table <ob1>) (arm-empty))) (effects

() ; no vars need genenerated in effects list ((del (on-table <ob1>))

(del (clear <ob1>)) (del (arm-empty))

(add (holding <ob1>)))))

(OPERATOR PUT-DOWN (params <ob>) (preconds ((<ob> OBJECT)) (holding <ob>)) (effects ()

((del (holding <ob>)) (add (clear <ob>)) (add (arm-empty))

(add (on-table <ob>)))))

(OPERATOR STACK

(params <ob> <underob>) (preconds

((<ob> Object)

(<underob> (and OBJECT (diff <ob> <underob>)))) (and (clear <underob>)

(holding <ob>))) (effects

()

((del (holding <ob>)) (del (clear <underob>)) (add (clear <ob> )) (add (arm-empty))

(add (on <ob> <underob>)))))

(OPERATOR UNSTACK

(params <ob> <underob>) (preconds

((<ob> Object) (<underob> Object)) (and (on <ob> <underob>)

(other-candidate-goals)

(true-in-state (on <y> <z>)))) (then reject goal (on <x> <y>)))

(CONTROL-RULE ARM-EMPTY-FIRST

(if (and (candidate-goal (arm-empty)) (true-in-state (holding <x>)))) (then select goal (arm-empty)))

(CONTROL-RULE SELECT-OP-UNSTACK-FOR-HOLDING (if (and (current-goal (holding <x>))

(true-in-state (on <x> <y>)))) (then select operator UNSTACK))

(CONTROL-RULE SELECT-BINDINGS-UNSTACK-HOLDING (if (and (current-goal (holding <x>))

(current-ops (UNSTACK))

(true-in-state (on <x> <y>))))

(then select bindings ((<ob> . <x>) (<underob> . <y>))))

(CONTROL-RULE SELECT-OP-UNSTACK-FOR-CLEAR (if (and (current-goal (clear <x>))

(true-in-state (on <y> <x>)))) (then select operator UNSTACK))

(CONTROL-RULE SELECT-BINDINGS-UNSTACK-CLEAR (if (and (current-goal (clear <y>))

(current-ops (UNSTACK))

(true-in-state (on <x> <y>))))

(then select bindings ((<ob> . <x>) (<underob> . <y>))))

(CONTROL-RULE SELECT-OP-PICKUP-FOR-HOLDING (if (and (current-goal (holding <ob>))

(true-in-state (on-table <ob>)))) (then select operator PICK-UP))

(CONTROL-RULE SELECT-OP-PUTDOWN-FOR-CLEAR (if (and (current-goal (clear <ob>))

(true-in-state (holding <ob>)))) (then select operator PUT-DOWN))

(CONTROL-RULE SELECT-OP-PUTDOWN-FOR-ARMEMPTY (if (and (current-goal (arm-empty))

(true-in-state (holding <ob>)))) (then select operator PUT-DOWN))

(CONTROL-RULE SELECT-BINDINGS-PUTDOWN (if (and (current-ops (PUT-DOWN))

(true-in-state (holding <x>)))) (then select bindings ((<OB> . <x>))))

(defun diff (x y) (not (eq x y)))

(defun other-candidate-goals ()

APÊNDICE 2

Definição do problema “p3”

(blockA blockB object)) (state

(and (clear blockA) (clear blockB) (on-table blockA) (on-table blockB) (arm-empty)))