LINGUAGENS DE PROGRAMAÇÃO DE AGENTES

Shoham (1993) propôs um paradigma chamado AOP (Programação Orientada a Agen- tes, do inglês: Agent Oriented Programming) que pode ser visto como uma especialização da Programação Orientada a Objetos (OOP, do inglês: Object-Oriented Programming). O Quadro 2 mostra a relação entre AOP e OOP:

Exemplos de linguagens que fazem parte do paradigma AOP e sua descrição são apre- sentadas por Bordini e Vieira (2003):

∙ AgentSpeak(L): inspirada na arquitetura BDI com sintaxe baseada em LISP (RAO, 1996);

∙ AgentTalk e 3APL: inspiradas no AgentSpeak(L) (HINDRIKS et al., 1997); ∙ Dribble: entende a linguagem 3APL com a noção de objetivos declarativos (RIEMS-

DIJK; HOEK; MEYER, 2003);

∙ Concurrent MetateM: a proposta inicial era que um agente fosse executado direta- mente de uma especificação em lógica temporal de tempo linear (FISHER, 1994); ∙ STAPLE: baseada na teoria de intenções conjuntas (KUMAR; COHEN; HUBER,

2002);

∙ Plataforma IMPACT: baseada em lógica deôntica (SUBRAHMANIAN, 2000); ∙ Congolog: baseada em cálculo de situações (GIACOMO; LESPÉRANCE; LEVES-

QUE, 2000);

∙ MINERVA: baseada em programação em lógica dinâmica (LEITE; ALFERES; PE- REIRA, 2001);

∙ Cálculo Ψ: outra abordagem BDI que possui o objetivo de dar suporte teórico para linguagens de programação visuais (KINNY, 2001);

∙ JAM (HUBER, 1999) e JACKL (HOWDEN et al., 2001): plataformas JAVA para desenvolvimento de agentes BDI.

Após o trabalho de Bordini e Vieira (2003) no ano de 2012 Dennis et al. acrescentaram seis linguagens desenvolvidas particularmente para a programação de agentes racionais. São elas: Jason (BORDINI; HÜBNER; WOOLDRIDGE, 2007), Jadex (POKAHR; BRAUBACH; LAMERSDORF, 2005), GOAL (HINDRIKS et al., 2000), CAN (WINIKOFF et al., 2002), SA- APL (WINIKOFF, 2007) e Gwendolen (DENNIS; FARWER, 2008).

3.4.1 Gwendolen

A linguagem de programação Gwendolen foi pensada para agentes racionais do mo- delo BDI (DENNIS; FARWER, 2008). Derivada do Java, é a primeira linguagem implementada na Camada de Infraestrutura de Agentes (AIL) (DENNIS; FISHER, 2016). O ciclo geral de raciocínio em Gwendolen é ilustrado na Figura 20.

O ciclo começa em (A) onde uma intenção é selecionada. Caso não haja uma, o am- biente é analisado para receber novas percepções ou mensagens que são processadas em (F) podendo gerar novas intenções. Selecionada uma intenção, planos são gerados para alcançá-la em (B) e em (C) um desses planos é selecionado para em (D) executar a tarefa no topo do plano.

Figura 20 – Ciclo de raciocínio em Gwendolen

Fonte: Adaptado de Dennis e Fisher (2016)

As propriedades da linguagem Gwendolen que representam as crenças, desejos e in- tenções são definidas como:

∙ Crenças: podem ser adquiridas por percepções do ambiente ou por deliberação. As crenças são predicados, por exemplo, rubble(5, 5) indicando que há sujeira na coor- denada (5,5). Para adicionar uma crença o predicado deve ser precedido pelo símbolo

+ e utiliza-se o símbolo - para indicar a remoção de uma crença (DENNIS; FISHER,

2016).

∙ Objetivos: representam os desejos do modelo BDI. São predicados precedidos por um ponto de exclamação, por exemplo, !Goto55 indicando que o agente tem o ob- jetivo de ir até a coordenada (5,5). Para adicioná-lo o predicado também deve ser precedido pelo símbolo + e utiliza-se o símbolo - para indicar a sua remoção. Após o predicado há uma indicação do seu tipo (por exemplo, +!Goto55 [achieve]) para indicar que o objetivo adicionado é do tipo achieve (DENNIS; FISHER, 2016). Em Gwendolen há dois tipos de objetivos (DENNIS; FISHER, 2016):

– Perform goal: quando um objetivo desse tipo é adicionado o agente procura e

executa um plano para alcançá-lo e descarta o objetivo sem verificar se ele foi realmente atingido;

– Achieve goal: quando um objetivo desse tipo é adicionado o agente procura

e executa um plano para alcançá-lo e verifica se uma crença foi adicionada correspondente ao objetivo. Se existe a crença o objetivo é descartado, caso contrário um novo plano é executado.

∙ Intenções: são vistas como uma matriz de quatro colunas onde são registrados:

– Eventos: novas percepções, mudança de crença, objetivos comprometidos e

assim por diante;

– Guards: uma condição que deve ser verdade antes de uma ação poder ser rea-

lizada. Um guard especificado como ⊤ representa uma condição que é sempre verdadeira;

– Tarefas: um plano de ações futuras, atualizações de crenças, comprometimento

com objetivos, entre outros;

– Unificadores: são as variáveis do programa. Tendo B = b significa que a variável

B foi unificada com o valor de b.

O Quadro 3 mostra a estrutura de um agente com a intenção de limpar um quarto. Quadro 3 – Exemplo de estrutura da intenção "limpar um quarto" em Gwendolen

evento guard tarefa unificador

+!limpar() sujo(Quarto) +!irAté(Quarto) Quarto = quarto1 +!limpar() ⊤ +!aspirar(Quarto) Quarto = quarto1

Fonte: Adaptado de Dennis e Fisher (2016)

Esta intenção foi desencadeada pelo desejo de limpar (demonstrado pelo compromisso com o objetivo limpar() nas duas linhas). A sequência de processamento é de cima para baixo, ou seja, se a crença sujo(Quarto) é verdadeira, ele se compromete com o desejo irAté(Quarto). Esse objetivo pode gerar novas tarefas como demonstrado no Quadro 4 (DENNIS; FISHER, 2016).

Quadro 4 – Exemplo de estrutura da intenção "limpar um quarto" estendida

evento guard tarefa unificador

+!irAté(Quarto) ⊤ +!plajejarRota(Quarto, Rota) Quarto = quarto1 +!irAté(Quarto) ⊤ +!seguir(Rota) Quarto = quarto1 +!irAté(Quarto) ⊤ +!entrar(Quarto) Quarto = quarto1 +!limpar() ⊤ +!aspirar(Quarto) Quarto = quarto1

Fonte: Adaptado de Dennis e Fisher (2016)

Cada uma das linhas será executada, podendo gerar novas tarefas, até que o desejo

aspirar(Quarto)seja alcançado (DENNIS; FISHER, 2016).

3.4.2 Exemplos de agentes em Gwendolen

Aqui serão apresentados três exemplos básicos de Gwendolen por Dennis e Fisher (2016). O primeiro trata-se de um agente que irá imprimir na tela hello.

No Código 1 é possível verificar a estrutura básica de um programa em Gwendolen. A linha 1 indica qual a linguagem utilizada na programação, isso porque o AIL permite criar programas a partir de outras linguagens, como: AgentSpeak, 3APL, Jadex e Metatem. O agente é nomeado como hello (linha 3) e não possui crenças iniciais, pois a seção Initial Beliefs (linha 5) está vazia, mas tem um objetivo inicial (Initial Goals (linha 7)) do tipo perform chamado

say_hello(linha 8). Na seção Plans (linha 10) os planos são iniciados.

Há um plano (linha 11) indicando que, se o objetivo for say_hello, a ação print (hello) deve ser executada. Para que isso ocorra o guard deve ser verdadeiro e o símbolo ⊤ indica isso, ou seja, sempre que o agente tiver o objetivo say_hello ele vai executar a ação print (hello) (DENNIS; FISHER, 2016).

Código 1 – Exemplo básico de um agente em Gwendolen

1 GWENDOLEN 2 3 : name : h e l l o 4 5 : I n i t i a l B e l i e f s : 6 7 : I n i t i a l G o a l s : 8 s a y _ h e l l o [ p e r f o r m ] 9 10 : P l a n s : 11 + ! s a y _ h e l l o [ p e r f o r m ] : {⊤} ← p r i n t ( h e l l o ) ;

Fonte: Dennis e Fisher (2016)

No Código 2 o objetivo do programa é que o agente se mova em um ambiente para pegar cascalho e, no cenário proposto por Dennis e Fisher (2016), há cascalho na posição (5, 5). O agente robot (linha 3) não possui crenças iniciais (linha 5) e tem como objetivo inicial ir até

a posição (5,5) (goto55 (linha 8)). Existem três planos. O primeiro diz que, se comprometendo com o objetivo goto55, o agente irá se mover até a posição (5,5) (linha 11). Quando a crença de que existe um cascalho nesta coordenada for adicionada ele irá segurá-lo com a ação lift_rubble (linha 12). Se ele acredita que está segurando o cascalho, então irá imprimir done na tela (linha 13) (DENNIS; FISHER, 2016).

Código 2 – Exemplo básico de um agente robô em Gwendolen

1 GWENDOLEN 2 3 : name : r o b o t 4 5 : I n i t i a l B e l i e f s : 6 7 : I n i t i a l G o a l s : 8 g o t o 5 5 [ p e r f o r m ] 9 10 : P l a n s : 11 + ! g o t o 5 5 [ p e r f o r m ] : {⊤} ← move_to ( 5 , 5 ) ; 12 + r u b b l e ( 5 , 5 ) : {⊤} ← l i f t _ r u b b l e ; 13 + h o l d i n g ( r u b b l e ) : {⊤} ← p r i n t ( d o n e ) ;

Fonte: Dennis e Fisher (2016)

O código 3 possui o mesmo objetivo e cenário do Código 2 com três diferenças básicas: a primeira é que o agente inicia com a crença (linha 5) de que pode haver cascalho nas posições (1, 1), (3, 3) e (5, 5). A segunda é que o objetivo inicial do agente (holding(rubble)) é do tipo

achieveou seja, o objetivo só será descartado quando a crença holding(rubble) for adicionada. A terceira diferença é que há planos onde o guard não é sempre verdadeiro (linha 14). Em vez disso a ação move_to(X, Y) só será executada se o agente acreditar que pode haver cascalho na posição (X, Y) e que de fato há cascalho na mesma posição (linha 15). A afirmação de haver um cascalho pode ser feita pela negação (com símbolo ∼) de que não há um cascalho.

Esse novo tipo de guard também é utilizado nos dois planos seguintes onde, acreditando estar na posição (X, Y), o agente adiciona a crença no_rubble(X, Y) caso não haja cascalho lá (linha 16), e quando tiver a crença de haver um cascalho em (X, Y) executa a ação de segurá-lo caso esteja em (X, Y) (linha 17) (DENNIS; FISHER, 2016).

Código 3 – Exemplo de um agente robô em Gwendolen 1 GWENDOLEN 2 3 : name : r o b o t 4 5 : I n i t i a l B e l i e f s : 6 p o s s i b l e _ r u b b l e ( 1 , 1 ) 7 p o s s i b l e _ r u b b l e ( 3 , 3 ) 8 p o s s i b l e _ r u b b l e ( 5 , 5 ) 9 10 : I n i t i a l G o a l s : 11 h o l d i n g ( r u b b l e ) [ a c h i e v e ] 12 13 : P l a n s : 14 + ! h o l d i n g ( r u b b l e ) [ a c h i e v e ] : 15 {B p o s s i b l e _ r u b b l e ( X , Y ) , ~B n o _ r u b b l e ( X , Y) } ← move_to ( X , Y ) ; 16 + a t ( X , Y) : {~B r u b b l e ( X , Y) } ← + n o _ r u b b l e ( X , Y ) ; 17 + r u b b l e ( X , Y ) : {B a t ( X , Y) } ← l i f t _ r u b b l e ; 18 + h o l d i n g ( r u b b l e ) : {⊤} ← p r i n t ( d o n e ) ;

Fonte: Dennis e Fisher (2016)

Neste trabalho a linguagem de programação de agentes Gwendolen será utilizada. A escolha foi feita por ser o Gwendolen uma linguagem específica para agentes racionais (DENNIS

et al., 2012) e ser possível fazer sua verificação formal através do MCAPL (Model Checking

Agent Programming Languages) (DENNIS, 2017).