Linguagens de Programação para SMA

Viviane Torres da Silvaviviane.silva@ic.uff.br

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

COMMIT(( agent, REQUEST, DO(time, action)),;;; msg condition

( B,[now, Friend agent] ANDCAN(self, action) ANDNOT [time, CMT(self, anyaction)]

), ;;; mental condition

self,DO(time, action) )

Se o agente recebe uma mensagem de outro agente pedindo para executar uma ação em um determinado momento

Se o agente crê que o outro agente é um amigo eo agente sabe executar a ação e

no momento não está executando nenhuma

ação

então o agente cria o compromisso de executar a ação

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

(((self ?agent REQUEST (?t (xeroxed ?x)))

(AND (CAN-ACHIEVE (?t xeroxed ?x)))

(NOT (BEL (*now* (vip ?agent))))

((ADOPT (INTEND (5pm (xeroxed ?x)))))

((?agent self INFORM (*now* (INTEND (5pm (xeroxed ?x)))))))

Se um agente te pede para fazer cópias

Se você sabe fazer

Se não é um agente VIP

Adota a intenção de fazer as cópias às 5pm(adoção do plano)

Informa ao agente que tem a intenção de fazer as cópias

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.

+localização (lixo, X):

localização (robô, X) & localização (lixeira, Y)<-recolher (lixo);

!localização (robô, Y);

jogar (lixo,lixeira).

eventos de ativação

contexto

corpo

Crença foi criada (existe lixo em X)

Objetivo a ser alcançado

AgentSpeak(L)

+!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).

Objetivo criado

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 multi-agentes 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

( amigos (eu, você)) S brigar (eu, você)– Não somos amigos desde o dia que brigamos

( 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á

Significa até que (until)

Significa desde que (since)

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)

– mensagens que reconhece: colocarElemento e tirarElemento

– mensagens que produz: pilhaCheira e elementoPosto

Definição interna: – o conjunto de regras do objeto

Ex:pilha (colocarElemento, tirarElemento) [pilhaCheia, elementoPosto]

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 mover-se 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 tremmoveu (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 futurotem (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çãomoveu (E, T) ¬ permissão (E, T’)

METATEM Concorrente

Existem vários objetos enviando mensagens, recebendo mensagens e executando assincronamente

A execução de um objeto não está orientada à mensagens. Sua execução é independente das mensagens que recebe e que envia.

Um objeto pode modificar sua interface dinamicamente, isso é, as mensagens que reconhece e como as manipula