Linguagens de Programação para SMA
Viviane Torres da Silva
[email protected]
http://www.ic.uff.br/~viviane.silva/isma
Algumas linguagens de programação

Agent0

Placa

AgentSpeak

Metatem
A idéia de uma linguagem de programação para SMA

1993: Yoav Shoham propôs a criação de um novo paradigma
de programação baseado nos aspectos sociais da computação

Programação orientada a agentes: os agentes são as entidades
da linguagem de programação

Programar os agentes em termos de seus estados mentais
– Crenças, desejos (ou objetivos) e intenções (ou planos)

Primeira linguagem de programação: Agent0
Agent0

Um agente tem:
– Um conjunto de capacidades
– Um conjunto de crenças
– Um conjunto de compromissos
– Um conjunto de regras de compromissos

São as regras que determinam se o agente executará uma ação

Cada regra de compromisso contém:
– Uma condição de mensagem que deve ser comparada com as
mensagens recebidas pelo agente
– Uma condição do estado mental que deve ser comparada com as crenças
do agente
– Uma ação que o agente terá o compromisso de executar se as condições
forem satisfeitas
Agent0

As ações podem ser:
– Privadas: ações internas do agente
– De comunicação: enviar mensagens

Uma mensagem pode ser de 3 tipos:
– Requests: um pedido para fazer uma ação
– Unresquests: uma negociação para fazer uma ação
– Inform: um envio de uma informação

Agent0 é uma extensão Lisp
Exemplo: Regra de compromisso
Se o agente recebe uma mensagem de outro agente
pedindo para executar uma ação em um determinado
momento
COMMIT(
( agent, REQUEST, DO(time, action)),;;; msg condition
Se o agente crê que o outro agente é um amigo e
o agente sabe executar a ação e
( B,
no momento não está
[now, Friend agent] AND
executando nenhuma
CAN(self, action) AND
ação
NOT [time, CMT(self, anyaction)]
), ;;; mental condition
então o agente cria o compromisso de executar a ação
self,
DO(time, action) )
Agent0

É possível implementar a comunicação e a cooperação entre os
agentes

Mas, ainda é um protótipo de linguagem de programação para
ilustrar alguns conceitos

A linguagem PLACA estende a linguagem Agent0:
– Possibilita o agente criar planos
Placa
Se um agente te pede para fazer cópias
(((self ?agent REQUEST (?t (xeroxed ?x)))
Se você sabe fazer
(AND (CAN-ACHIEVE (?t xeroxed ?x)))
(NOT (BEL (*now* (vip ?agent))))
Se não é um agente VIP
Adota a intenção de fazer as cópias às 5pm
(adoção do plano)
((ADOPT (INTEND (5pm (xeroxed ?x)))))
Informa ao agente que tem
a intenção de fazer as cópias
((?agent self INFORM
(*now* (INTEND (5pm (xeroxed ?x)))))))
AgentSpeak(L)

Linguagem baseada em eventos e ações

O comportamento do agente é implementado com a linguagem

As crenças, os objetivos (ou desejos) e os planos (ou intenções)
podem ser descritos em AgentSpeak
– Crenças: estado do agente, do ambiente e de outros agentes
– Objetivos: estado que o agente quer alcança ou verificar
– Planos: programa para alcançar os objetivos

Um programa em AgentSpeak consiste de um conjunto de
crenças e um conjunto de planos
AgentSpeak(L)

Exemplo:
– Existem faixas por onde podem estar os carros
– As faixas podem ter lixo
– Robôs têm a obrigação de pegar o lixo e colocar em lixeiras
– Robôs podem mover-se de uma faixa para a outra
Crenças:
 Crenças atômicas: “classes” para criar instancias
– Localização (robô, faixa), localização (carro, faixa),
adjacente (faixa, faixa)

Crenças básicas: instâncias das classes
– adjacente (a, b), localização (robôA, a)
AgentSpeak(L)
Objetivo:
 Objetivo para ser alcançado: !g(t)
– Agente quer alcançar um estado onde g(t) é verdade
– !limpo (b) : agente quer que a faixa b esteja limpa

Objetivo para ser testado: ?g(t)
– Agente quer verificar se g(t) é uma crença verdadeira
– ?localização (carro, b) : agente pergunta se existe algum carro na faixa b

Novos objetivos e novas crenças podem ser criados e objetivos
e crenças podem ser apagados.
– +localização (lixo, a) : criação da crenças que diz que existe lixo na
faixa a
– +!limpo (a) : criação do objetivo para limpar a faixa a
AgentSpeak(L)
Plano
 Tem uma cabeça e um corpo
 Cabeça consiste de:
– Eventos de ativação do plano: criação ou destruição de crenças e
objetivos.
– Contexto: as crenças que devem ser verdadeiras para executar o plano.

Corpo consiste de:
– Seqüência de ações e objetivos.
eventos de ativação

Crença foi criada (existe lixo em X)
contexto
+localização (lixo, X):
localização (robô, X) & localização (lixeira, Y)
<-recolher (lixo);
Objetivo a ser alcançado
!localização (robô, Y);
corpo
jogar (lixo,lixeira).
AgentSpeak(L)


Objetivo criado
+!localização (robô, Y):
localização (robô, Y) <- verdade
+!localização (robô, Y):
localização (robô, X) &
(não (X = Y)) &
adjacente (X, Z) &
(não (localização (carro, Z)))
<- mover (X, Z);
+!localização (robô, Y).
Execução de um programa em AgentSpeak(L)

Se existem mais eventos para serem processados, selecionar
um (Se).

Retirar da biblioteca de planos todos os planos ativados pelo
evento e que podem ser executados com as circunstancias
atuais.

Selecionar um plano (S0), criando uma intenção de execução

Executar o plano, selecionando a primeira intenção (Si). Se
encontrar uma ação, executar a ação, se encontrar um objetivo
incluir na lista de eventos que serão processados.
METATEM

É uma linguagem para implementação de sistemas multiagentes que utiliza lógica temporal para especificar o
comportamentos dos agentes

Lógica temporal é uma lógica clássica com operadores modais
para descrever como a verdade sobre as proposições podem
variar no tempo

As especificações são executadas para gerar o comportamento
dos agentes
METATEM

importante (agentes)
– É verdade agora e sempre será que os agentes são importantes

 importante (Metatem)
– Em algum momento no futuro Metatem será importante

importante (Prolog)
– Em algum momento no passado, Prolog foi importante
Significa desde que (since)

( amigos (eu, você)) S brigar (eu, você)
– Não somos amigos desde o dia que brigamos
Significa até que (until)

( amigos (eu, você)) U desculpar-se (você)
– Não somos amigos até que você se desculpe (em algum momento no futuro)

 desculpar-se (você)
– Amanha (no próximo estado) você se desculpará
METATEM


Um programa em Metatem é um conjunto de regras
Executando regras:
Passado  Futuro
Se verifica se os fatos do passado são verdades
 Se o passado de uma regra é verdade, “ativa-se” os fatos do
futuro

trem (E, T) ^ semáforo (vermelho)  trem (E, T)
trem (E, T) ^ semáforo (verde) ^ mover (T,E,S)  trem (S, T)
noivos (Ana, João)   casados (Ana, João)
Componentes de um objeto

Definição da interface:
– define quais mensagens o objeto reconhece (recebe) e quais produz
(envia)
Ex:pilha (colocarElemento, tirarElemento) [pilhaCheia, elementoPosto]
– mensagens que reconhece: colocarElemento e tirarElemento
– mensagens que produz: pilhaCheira e elementoPosto

Definição interna:
– o conjunto de regras do objeto
Exemplo: Trens e Estações
Interfaces:

estação (mover, permissão)[moveu]
– mover (E, T) : mensagem que pede a permissão para o trem T moverse para a estação E
– permissão (E, T) : mensagem que permite que o trem T se mova para
a estação E
– moveu (E, T) : mensagem que informa que o trem T se moveu para a
estação E
– tem (E,T): mensagem que informa que o trem T está na estação E
– linha (L, T) : mensagem que informa que a linha L tem o trem T
– próxima (E, L, F): msg que informa que a estação adjacente a E é F na
linha L.
Regras:
1.
Se a estação tem o trem e o trem não se moveu, o trem segue
na estação
tem (E,T) ^ ¬ moveu (F, T)  tem (E,T)
Exemplo: Trens e Estações
Regras:
2. Se um trem acaba de mover-se para uma estação, a estação
tem o trem
moveu (E,T)  tem (E,T)
3.
Se uma estação tem um trem e acaba de receber a permissão
de mover o trem para a próxima estação, o trem estará na
próxima estação no futuro
tem (E,T) ^ permissão (F, T) ^ línea (L,T) ^ próxima (E, L, F) 
moveu (F,T)
4.
Se um trem acaba de mover-se para uma estação, a estação
não pode dar a permissão para nenhum trem mover-se para a
estação
moveu (E, T)  ¬ permissão (E, T’)