Universit

1
Università degli Studi di
LAquila
                   

• DALI
• Logic Programming Language

2
Dali un linguaggio logico per Agenti e Sistemi
Multiagente
Un agente e una entita software situata in un
ambiente,capace di azioni autonome allo scopo
di raggiungere i propri obiettivi

• Caratteristiche di DALI
• Classi di eventi e loro interazione
• Eventi esterni
• Eventi interni
• Eventi del presente
• Eventi del passato
• Azioni
• Interfogliamento delle attivita
• Priorita nelle azioni
• Priorita negli eventi
• Gestione dei goals nel planning
• Memoria

Very similar to Prolog
Easy-to-use
DALI
Logical Semantics
3
Dali gli eventi esterni e del presente
E' la relazione con l'ambiente a determinare la
configurazione del sistema cognitivo di un
organismo (Maturana)
Stage 1 reazione allevento Funzione
si innesca la reazione allevento secondo le
direttive specificate dalla regola reattiva
contenuta nel programma logico DALI.

suona_la_svegliaEgtmi_alzoA
Un evento del presente fa in modo che il
processo di reazione ad un evento interno venga
anticipato da un processo di ragionamento
(tipico degli eventi interni). Cio garantisce la
distinzione tra ragionamento sugli eventi e
reazione agli eventi!
arriva_qualcuno-suona_il_campanelloN. arriva_qual
cunoIgtmi_vestoA. mi_vestolt sono_svestitoP. suona
_il_campanelloEgtapro_la_portaA
Stage 2 dopo la reazione, l agente e capace di
ricordare levento esterno. Funzione
ragionamento su cosa e accaduto nel passato.

sono_pigro-suona_la_svegliaP
not(mi_alzoP)
sono_pigroIgt prendo_un_giorno_di_f
erieA
Gli eventi esterni vengono processati sulla
base della loro priorita (alta o normale). Gli
eventi ad alta priorita hanno precedenza
assoluta sugli altri.
4
Dali gli eventi interni
Gli agenti riflettono
Un evento interno e una conclusione raggiunta
dallagente alla quale lagente reagisce
similarmente ad un evento esterno! Le
conclusioni interne scatenano la proattivita
dellagente!

• Il comportamento di un evento interno e
  determinato dalle direttive dellutente
• ogni quanto tempo tentare levento
• quante volte ad un evento si deve reagire
• forever
• una volta, due volte,...
• e quando
• in assoluto
• quando cambia una determinata condizione di
  innesco
• fino a quando (forever, fino ad un certo tempo,
  fino ad una certa condizione)

Stage1 le condizioni di innesco (eventi
interni o esterni a cui lagente ha
reagito,azioni compiute,conoscenza,) sono tutte
true, si scatena la reazione Stage2 dopo
la reazione, lagente e capace di
ricordare levento interno
cucino-acceso_gasP,
metto_pentola_sul_gasP,
minuti_cottura(25),passati_minuti(25).
cucinoIgttolgo_pentola_dal_gasA,spengo_gasA.
Un evento interno puo corrispondere ad una
azione. Piu eventi interni possono essere
correlati scatenando inferenze successive!
5
Dali gli eventi interni (1)
Concatenare il pensiero e dedurre...
sintomo1('demo1/knowledge/log.txt',H1,Time)-finda
ll(str(AT,D),clause(log(_,_,_,AT,_,_,D,_),_),L),
length(L,Lu),Lugt5,remove_duplicates
(L,L1), member(M,L1),arg(1,M,H1),a
rg(2,M,Time), carica_fileP('demo1/
knowledge/log.txt',_).sintomo1('demo1/knowledge/
log.txt',H1,Time)-findall(str(AT,D),clause(log(_,
_,_,AT,_,_,D,_),_),L),
length(L,Lu),Lugt5,remove_duplicates(L,L1),
member(M,L1),arg(1,M,H1),arg(2,M,Time),
intervalloP(_).sintomo1I(X,H1,Tim
e)gtwrite(sintomo_uno(X,H1,Time)),nl.sintomo2(T)
-carica_fileP(_,_),datime(T),arg(4,T,H),Hgt9.sin
tomo2(T)-carica_fileP(_,_),datime(T),arg(4,T,H),H
lt8.sintomo2I(T)gtwrite(sintomo_due(T)),nl.sint
omo3(X)-carica_fileP(X,_),datime(T),arg(4,T,H),Hlt
9,Hgt8.sintomo3(_)-intervalloP(_),datime(T),arg(4
,T,H),Hlt9,Hgt8.sintomo3I(X)gtwrite(sintomo_tre(X))
,nl, clause(agent(A),_),
messageA(manager,inform(changed_time(X),A)).
6
Dali gli eventi interni (2)
Concatenare il pensiero e dedurre...
attacco1(P,date(A,Me,G),time(O,M))-sintomo2P(T),
arg(1,T,A),arg(2,T,Me),arg(3,T,G),
arg(4,T,O),arg(5,T,M),
clause(log(_,_,P,_,_,_,date(A,Me,G),time(O,M1,_)),
_),M-2ltM1,M1ltM3.attacco1I(P,date(A,Me,G),time(
O,M))gtclause(agent(Ag),_),
messageA(manager,send_message(attacco1(P,date(A,Me
,G),time(O,M,00)),Ag)).attacco2(X,H,D)-sintomo1
P(X,H,D).attacco2I(X,H,D)gtclause(agent(A),_),tra
sf(X,K),trasf(H,H1),
clause(log(_,_,_,H,_,_,D,T),_),
messageA(manager,send_message(attacco2(H1,D,T,K),A
)).attacco3(H,D,_)-informP(avviso_attacco(H,D,_
),_),ntrasf(H,H1),clause(log(_,_,H1,_,_,_,_,_),_).
attacco3I(H,D,_)gtclause(agent(A),_),
messageA(manager,send_message(attacco3(H,D,
_),A)).
7
Dali i goals

• Dali possiede due tipi di goals
• goals che lagente tenta di perseguire
• Sono legati agli eventi interni. Quando un agente
  invoca un goal, attiva levento interno
  corrispondente che tenta le precondizioni. Se
  questultime diventano vere, si attiva il piano.
• goals che lagente verifica se eseguiti
• Quando un agente trova un goal da testare
  verifica se vi e il corrispondente evento del
  passato o un fatto.
• I goals da ottenere sono trattati come eventi
  interni. Se raggiunti, sono ricordati dall
  agente come eventi del passato.

goEgtput_shoesG. put_shoes-put_right_shoeG, put_l
eft_shoeG, right_shoe_onP,left_shoe_onP. put_shoes
Igtleft_and_right_shoes_onA, retractall(past(_,_,_
)). put_right_shoe-put_right_sockG,right_sock_on
P. put_right_shoeIgtright_shoe_onA. put_left_shoe
-put_left_sockG,left_sock_onP. put_left_shoeIgtle
ft_shoe_onA. put_right_sock-have_right_sockP. pu
t_right_sockIgtright_sock_onA. put_left_sock-hav
e_left_sockP. put_left_sockIgtleft_sock_onA.
8
STRIPS e DALI planning
Lidea dello STRIPS planner e dividi e
conquistaper creare un piano per ottenere un
insieme di goals,occorre creare un piano per
ottenere un goal ed un piano per ottenere il
resto
Facciamo la spesa...con DALI
vai_al_supermercato-sono_a_casaP,isa(supermercato
_aperto). vai_al_supermercato-sono_in_ferramentaP
,isa(supermercato_aperto). vai_al_supermercatoIgts
ono_al_supermercatoA. vai_alla_ferramenta-sono_
al_supermercatoP. vai_alla_ferramenta-sono_a_casa
P. vai_alla_ferramentaIgtsono_in_ferramentaA. vai
_a_casa-sono_in_ferramentaP. vai_a_casa-sono_al_
supermercatoP. vai_a_casaIgtsono_a_casaA. compra_
banana-sono_al_supermercatoP. compra_bananaIgtcom
pro_bananaA. ... compra_chiodi-sono_in_ferramenta
P. compra_chiodiIgtcompro_chiodiA.
vaiEgtsono_a_casaA,compra_tuttoG. compra_tutto-pr
ocura_bananaG,procura_latteG,vai_a_casaG, pago_ban
anaP,pago_latteP,sono_a_casaP. compra_tutto-procu
ra_chiodiG,vai_a_casaG,pago_chiodiP,sono_a_casaP.
compra_tuttoIgtacquisto_tuttoA. procura_banana-
vai_al_supermercatoG,compra_bananaG, sono_al_super
mercatoP,compro_bananaP. procura_bananaIgtpago_ban
anaA. ... procura_chiodi-vai_alla_ferramentaG,co
mpra_chiodiG, sono_in_ferramentaP,compro_chiodiP.
procura_chiodiIgtpago_chiodiA.
9
Dali la comunicazione e le azioni

• Atomi azione rappresentano in DALI le azioni. Le
  azioni hanno
• Sempre successo se non hanno precondizioni
• Hanno successo solo quando la condizione e true,
  se hanno precondizioni.

Linterprete DALI, quando una azione e true,la
pone in coda in attesa di essere ripresa ed
eseguita. Cio permette il controllo sulle azioni
ed evita che una azione venga compiuta quando il
contesto non lo permette (servire una birra se le
birre sono finite!). Quando cio accade lazione
viene rimessa in coda in attesa che il contesto
la renda ammissibile. Se questo non accade
lagente la elimina.

• Nel linguaggio logico DALI le azioni sono
  ettichettate con una A e possono essere
• una azione semplice (scritta sullo schermo o su
  un file)
• un messaggio inviato ad altri agenti (con il
  suffisso message)
• LE AZIONI POSSONO AVERE PRIORITA ALTA O NORMALE!

10
Dali gli eventi del passato
"risolvere" un problema equivale a
"comprenderlo" e "comprendere" significa, in
ultima analisi, ricondurre la situazione presente
a una situazione gia' nota del passato

• Il periodo di tempo in cui un evento del passato
  viene ricordato e anchesso definito dalle
  direttive dellutente
• forever
• fino ad un certo tempo (until_time)
• fino a quando si verifica una data condizione
  (until_cond)

sunny_weatherE gt open_the_windowA. rainy_weathe
rEgtclose_the_windowA open_the_windowltclose_the_
windowP close_the_windowlt open_the_windowP
11
Dali la architettura multiagente
GUSCIO DALI Elabora,estrae e gestisce gli eventi,
le azioni, le regole e la comunicazione
dellagente DALI in esso contenuto
PROGRAMMA LOGICO DALI Descrive il comportamento
dellagente utilizzando la sintassi del
linguaggio logico DALI
Tuples Space
12
La architettura di un agente DALI
Pre-processing
file.txt
Processing Eventi Azioni Goals
Comunicazione
Comunicazione
13
I files di un agente DALI
file.ple
file.txt
File.plf
file.pl
14
Le liste del file ple
Eventi esterni
invitation,sega_la_legna,set,get,notify,call,ack,
reply,return.go_by_car,wait_ack(DestAgent,Time
Stamp,SeqId,AckContent), wait_reply(DestAgent,Time
Stamp,SeqId,VarName,VarValue),. go_by_car,tak
e_the_bus,ask_susan_to_join,aiuto(X), message(To,s
et(A,T,SeqId,VarName,VarValue)), message(To,get(A,
T,SeqId,VarName)),. go_by_car...
..
Eventi interni
Azioni
Condizioni
Eventi del presente
Goals da ottenere
Goals da testare
Fatti da ricordare
15
Il naming del file pl
eve(predator_attacks(var_X))-once(try_to_escape(v
ar_X)).try_to_escape(var_X)-a(fly(var_X)).try
_to_escape(var_X)-a(run(var_X)).cd(fly(var_X))
-evp(bird(var_X)),not(evp(abnormal(var_X))).
16
Le direttive del file plf
action(Azione,normal).
action(Azione,high).
external_event(Evento_esterno,normal).
past_event(Evento/Azione,20).
mod(Evento_esterno,check).
internal_event(Evento_interno,3,forever,true,until
_cond/until_date(Condizione/Data)).
internal_event(Evento_interno,3,1,change(),forev
er).
17
La comunicazione in DALI
18
Percezione ed azione

• Un agente è un oggetto attivo con la capacità di
  percepire, ragionare ed agire.
• Assumiamo che
• un agente ha una KB ed un meccanismo per fare
  inferenza sulla sua conoscenza
• un agente ha la CAPACITA di COMUNICARE

parte PERCEZIONE (ricevere messaggi)
parte AZIONE (inviare messaggi)
19
Cooperare o competere?
La comunicazione permette agli agenti di
coordinare le loro azioni ed il loro
comportamento. La coordinazione è una proprietà
di un sistema di agenti che compiono una certa
attività in un ambiente condiviso. La
COOPERAZIONE è una coordinazione tra agenti non
antagonisti mentre la NEGOZIAZIONE è una
coordinazione tra agenti competitivi o
interessati a se stessi.
20
Obiettivo

• dotare il linguaggio di un robusto protocollo di
  comunicazione capace di fornire agli agenti
  opportune primitive per cooperare
• assicurare un 'filtro' sui messaggi in ingresso
  ed in uscita in modo da proteggere le entità
  software da atti comunicativi dannosi
• introdurre un livello di meta-ragionamento per
  agevolare linterpretazione dei messaggi

21
Nuova architettura degli agenti Dali

• Larchitettura DALI precedente ha subito notevoli
  variazioni passando
• da un unico strato a tre strati consistenti in
• filtro sulla comunicazione e protocollo
• applicazione del meta ragionamento con supporto
  di ontologie
• interprete

22
Difendere gli agenti

• In un progetto di cooperazione tra agenti
  intelligenti è necessario tenere il più possibile
  sotto controllo il processo di comunicazione. Un
  agente, se non opportunamente difeso, può
  essere soggetto a danneggiamenti della base di
  conoscenza o delle regole comportamentali.
• Talvolta, però, può accadere che un agente invii
  ad un altro un messaggio con contenuto sbagliato
  arrecando volontariamente o involontariamente un
  enorme danno. Come riconoscere un messaggio
  giusto da uno sbagliato?

23
Il filtro Dali

• Come riconoscere un messaggio giusto da uno
  sbagliato? Il filtro adottato in DALI cerca di
  rispondere, per quanto possibile, a questo
  quesito.
• Quando un messaggio viene recepito, esso viene
  sottoposto ad un check fornito da una struttura
  altamente modificabile dallutente ed adeguabile
  al contesto.
• Tale struttura controlla che i campi del
  messaggio rispondano ai vincoli imposti dal
  programmatore, altrimenti il messaggio viene
  cancellato non producendo alcun effetto.

24
I vincoli sui messaggi in ingresso

• Le direttive sul filtro sono contenute nel
  file communication.txt accessibile direttamente
  dallutente. Ciò evita di dover cambiare ogni
  volta il codice dellinterprete.

told(Ag,tipo_messaggio(_))- constraint1,constrain
t2,...,constraintn.
25
I vincoli sui messaggi in ingresso
told(Sender_agent,send_message(Evento_esterno))-
not(evp(inaffidabile(Sender_agent))),
interessato_a(Evento_esterno).
told(Sender_agent,execute_proc(Procedure))-
not(evp(inaffidabile(Sender_agent))),
conosco(Procedura).
told(Sender_agent,query_ref(Proposizione,3))-
not(evp(inaffidabile(Sender_agent))),
carina(Sender_agent).
26
I vincoli sui messaggi in uscita

• Le condizioni di filtro dei messaggi in uscita
  sono contenute
• sempre nel file communication.txt ma hanno
  tell come
• suffisso
• tell(To,From,type_message(_))-
• 
  constraint1,...,constraintn.
• tell(To,_,send_message(_))-
• 
  not(evp(enemy(To))).

27
Applicazione del meta-ragionamento e delle
ontologie

• In un sistema multi-agente dove più entità
  software cooperano alla realizzazione di un
  obiettivo, come ad esempio la sicurezza di un
  settore, non tutti i componenti parlano la stessa
  lingua ma, anche allinterno della stessa lingua,
  non tutti utilizzano le stesse parole per
  esprimere un dato concetto.
• In questo caso si può istruire lagente ad
  applicare un processo di ragionamento che lo
  induca a capire se la situazione che sta
  incontrando è riconducibile ad una già conosciuta.

28
Cosa è una ontologia

• Una ONTOLOGIA è una specifica degli oggetti,
  concetti e
• relazioni in una area di interesse.
• Una ontologia include
• proposizioni vere o false indipendentemente da un
  certo individuo
• Proprietà di singoli individui
• Relazioni tra coppie di individui o più
  individui.
• dove per individuo si intende qualsiasi cosa
  gente, colori,
• emozioni, numeri,

29
Lutilizzo di una ontologia

• Supponiamo di avere la seguente regola reattiva.
• caso1E(X)gtazione1A(X),azione2A(X).
• Se lagente sà che caso1 è semanticamente
  equivalente a caso2, può rispondere allevento
  esterno caso2 pur conoscendo soltanto caso1.
• Che caso1 sia equivalente a caso2 può essere una
  informazione data a run-time dallagente che
  invia il messaggio al destinatario oppure può
  essere contenuto nell ontologia associata
  allagente che riceve il messaggio.

30
Il livello di meta-ragionamento

• Il ragionamento su una asserzione o chiamata ad
  evento esterno è stato ottenuto tramite la
  procedura meta agganciata tra lo strato
  superiore di check e quello inferiore
  dellinterprete vero e proprio.
• Tale procedura è contenuta nel file
  communication.txt e può essere modificata
  dallutente senza intaccare il codice
  dellinterprete. Ciò permette di aggiungere
  potenzialità a livello di meta-ragionamento in un
  agente senza avere conoscenze troppo approfondite
  sullintero sistema.

31
Come è fatto il meta-ragionamento
meta(Initial_term,Final_term,Agent_Sender)-clause
(agent(Agent_Receiver),_), functor(Initial_term,Fu
nctor,Arity),Arity0, ((ontology(Agent_Sender,Func
tor,Equivalent_term) ontology(Agent_Sender,Equiva
lent_term,Functor)) (ontology(Agent_Receiver,Func
tor,Equivalent_term) ontology(Agent_Receiver,Equi
valent_term,Functor))), Final_termEquivalent_term
. meta(Initial_term,Final_term,Agent_Sender)-fun
ctor(Initial_term,Functor,Arity),Arity2, symmetri
c(Functor),Initial_term..List, delete(List,Functo
r,Result_list), reverse(Result_list,Reversed_list)
, append(Functor,Reversed_list,Final_list), Fina
l_term..Final_list.
piove
cade_acqua
ama(pippo,pina)
ama(pina,pippo)
32
Come è fatto il meta-ragionamento
Insert name of Receiver pippo. Insert
Language italian. Insert Ontology
. Insert name of Sender pino. Insert
message confirm(ama(pippo,gina),pino). Insert
name of Receiver pippo. Insert Language
italian. Insert Ontology . Insert name of
Sender anne. Insert message
query_ref(ama(gina,X),anne).
Pippo
Anne
send_message_to(anne, inform(query_ref(ama(gina,fd
var_6),1), motivation(no_values),pippo),italian,
) send_message_to(anne, inform(query_ref(ama(gin
a,fdvar_7),1), values(ama(pippo,gina)),pippo),it
alian,)
33
Protocollo di comunicazione

• Ci sono diversi protocolli attraverso i quali gli
  agenti possono comunicare. Uno di essi è il
  protocollo FIPA (http//www.fipa.org/) che è
  basato sul concetto di messaggio. I messaggi sono
  inviati avanti ed indietro tra un agente sender
  ed un agente receiver ed hanno una specifica
  strutturazione.
• FIPA disciplina tutti gli atti comunicativi e
  definisce anche quali messaggi il receiver può
  inviare in risposta ad un dato messaggio

34
Il protocollo FIPA

• Seguendo il protocollo di base FIPA, l'unità di
• comunicazione di DALI ha assunto la seguente
• struttura
• receiver nome dell'agente che riceve il
  messaggio (lo stesso del file di attivazione)
• language il linguaggio per mezzo del quale il
  messaggio è espresso
• ontology l'ontologia adottata dall'agente sender
  per interpretare il messaggio
• sender nome dell'agente che invia il messaggio
• content contenuto del messaggio.

35
Primitive Dali e primitive FIPA

• Il nuovo interprete Dali vede il protocollo di
  comunicazione come due librerie. Ciò permette di
  associare ad un agente protocolli diversi senza
  modificare il codice interno dellinterprete
  variando semplicemente due files
  communication.txt dove si trova il check ed il
  file communication_fipa.pl che contiene le
  primitive di comunicazione.
• Dali ha adottato, al momento, diverse tipologie
  di messaggi FIPA aggiungendone alcuni fuori dal
  protocollo data la particolarità degli agenti
  Dali. Il protocollo FIPA, infatti, disciplina la
  comunicazione tra agenti che cooperano allo
  svolgimento di obiettivi visti come sequenze di
  azioni.

36
Send_message (DALI)

• Permette ad un agente Dali di inviare un
  messaggio ad un altro agente allo scopo di
  attivare una regola reattiva tramite un evento
  esterno.
• Un evento esterno nel linguaggio Dali è un
  messaggio o uno stimolo ambientale di cui
  lagente prende atto e a cui risponde applicando
  la corrispondente regola reattiva nel suo
  programma logico, se la possiede.
• La sintassi del send_message per inviare un
  evento esterno da modulo utente è
• send_message(Evento_esterno, Agente_sender)

37
Send_message (DALI)
predator_attacksE(X)gtonce(try_to_escape(X)). try_
to_escape(X)-flyA(X). try_to_escape(X)-runA(X).
fly(X)ltbirdP(X),not(abnormalP(X)).
New message Insert name of addressee animal.
Insert
message confirm(bird(duck),pippo). New
message Insert From pippo.
Insert message send_message(predator_attacks(d
uck),pippo).
make(run(penguin),96328) make(fly(duck),147492)
38
Propose (FIPA)

• Identifica lazione di sottomettere da parte di
  un agente ad un altro la proposta di compiere una
  certa azione date alcune precondizioni.
• Le precondizioni sono inserite allinterno di una
  lista aggregata al messaggio.
• La nuova strutturazione permette ad un agente
  Dali di chiedere ad un altro lesecuzione di una
  singola azione, senza invocare alcuna regola,
  purchè questa azione sia conosciuta dallagente e
  quindi inserita allinterno del programma logico.

39
Propose

• Laccettazione della proposta di compiere una
  azione è legata alla verifica delle condizioni
  relative al messaggio. Se esse sono vere,
  lagente che ha ricevuto il propose, invierà un
  messaggio allagente proponente dicendo di
  accettare la proposta, altrimenti la rifiuterà.
• Ogni azione Dali è sottoposta alla verifica delle
  precondizioni allazione interne al programma
  logico.
• La sintassi del propose per il modulo utente è
• propose(Action,condizione1,,condizionen,
  Agente_sender)

40
Accept-proposal (FIPA)

• Identifica latto di accettare la proposta di
  compiere una azione da parte di un agente ed è
  strettamente legato allatto comunicativo
  propose.
• Questo comando è interno al processo di
  comunicazione e la sua sintassi è
• message(Ag_receiver,
• accept_proposal(Azione_accettata,
• condizione1,condizionen, Agente_sender))
• dove le condizioni possono essere delle
  eventuali richieste
• insite nellaccettazione della proposta.

41
Reject-proposal (FIPA)

• Identifica latto di rifiutare la proposta di
  compiere una azione da parte di un agente ed è
  strettamente legato allatto comunicativo
  propose.
• Questo comando è interno al processo di
  comunicazione e la sua sintassi è
• message(Agente_receiver,
• reject_proposal(Azione_rifiutata,
• ragione1,,ragionen, Agente_sender))
• dove le ragioni possono essere delle eventuali
  motivazioni
• del rifiuto della proposta.

42
Failure (FIPA)

• Identifica latto di dire ad un altro agente che
  una azione è stata tentata ma il tentativo è
  fallito.
• Ciò accade quando, pur avendo accettata la
  proposta di compiere una azione, un agente
  verifica che le condizioni interne al programma
  logico non la permettono.
• La sintassi di tale primitiva è
• message(Agente_receiver,failure(Azione_falli
  ta,motivation(Motivo), Agente_sender))

43
Propose
dangerEgtonce(ask_for_help). ask_for_help-call_po
liceA. call_policelthave_a_phoneP. ask_for_help-s
creamA.
New message Insert name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From pippo.
Insert message propose(call_police,near_h
ome,pippo).
send_message_to(pippo, reject_proposal(call_police
,, pippo),italian,)
44
Propose
dangerEgtonce(ask_for_help). ask_for_help-call_po
liceA. call_policelthave_a_phoneP. ask_for_help-s
creamA.
New message Insert name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From gino.
Insert message propose(call_police,,
gino).
send_message_to(pippo, failure(call_police, motiva
tion(false_conditions), pippo),italian,)
45
Propose
dangerEgtonce(ask_for_help). ask_for_help-call_po
liceA. call_policelthave_a_phoneP. ask_for_help-s
creamA.
confirm(have_a_phone,pippo). New
message Insert name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From anne. Insert
message propose(call_police,,anne).
send_message_to(anne, accept_proposal(call_police,
, pippo),italian,) make(call_police,78653)
46
Cancel (FIPA)

• Identifica la richiesta di cancellare una certa
  azione ordinata da un agente.
• Nel caso di un agente Dali con un numero di
  eventi ed azioni limitate, la richiesta di
  compiere una azione viene eseguita in tempi
  relativamente più brevi di quelli dellarrivo di
  una richiesta di cancellazione.
• la cancellazione della azione avviene sia dalla
  coda ad alta priorità che da quella a priorità
  normale.
• La sintassi del comando è
• message(Agente_receiver,cancel(Azione_canc,
• Ag_sender))

47
Cancel (FIPA)
dangerEgtonce(ask_for_help). ask_for_help-call_po
liceA. call_policelthave_a_phoneP. ask_for_help-s
creamA.
New message Insert name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From anne. Insert
message cancel(call_police,,anne).
48
Execute_proc (DALI)

• Questo atto comunicativo riguarda la chiamata di
  semplici procedure allinterno del programma
  logico Dali.
• Il codice non si limita ad invocare il check ma
  fa riferimento allo strato del meta-ragionamento
  ed alle ontologie.
• La sintassi da modulo utente e
• execute_proc(Procedura, Agente_sender)

49
Execute_proc (DALI)
scrivi(X)-write(X),nl.
New message Insert name of addressee anne.
Insert Language
italian. Insert
Ontology .
Insert From pippo.
Insert message execute_proc(scrivi(pippo),pipp
o).
pippo
50
Execute_proc (DALI)
scrivi(X)-write(X),nl.
New message Insert name of addressee anne.
Insert Language
italian. Insert
Ontology scrivi.
Insert From pippo.
Insert message execute_proc(scrivo(pippo),pi
ppo).
pippo
Ontologia
51
Query_ref (FIPA)

• Indica latto di domandare ad un altro agente se
  conosce uno o un insieme di fatti che dimostrano
  la proprietà richiesta.
• Come primo argomento il query_ref prende la
  proprietà richiesta, come secondo accetta un
  numero che è il limite sul numero di matching che
  un agente si aspetta di ottenere.
• La sintassi di questo atto comunicativo per il
  modulo utente è
• query_ref(Proprietà,N,Agente_sender)

52
Query_ref (FIPA)
??? Non ho nellontologia che vado è simmetrico!
send_message_to(anne, inform(query_ref(vado(montag
na, fdvar_1),1), motivation(no_values),pippo), ita
lian,) send_message_to(anne, inform(query_ref(va
do(fdvar_3,montagna),1),values(vado(domani, monta
gna)),pippo),italian,)

New message Insert name of addressee pippo.
Insert From pino.
Insert message confirm(vado(domani,montagna),p
ino). New message Insert name of addressee
pippo. Insert
From anne. Insert message
query_ref(vado(Y,montagna),1,anne).
past(inform(query_ref(vado(montagna,fdvar_1),1), m
otivation(no_values), pippo), 479379, pippo).
53
Query_ref (FIPA)
symmetric(vado).
send_message_to(anne, inform(query_ref(vado(montag
na,fdvar_4),1), values(vado(domani,montagna)),pi
ppo),italian,)

New message Insert name of addressee pippo.
Insert From pino.
Insert message confirm(vado(domani,montagna),p
ino). New message Insert name of addressee
pippo. Insert
From anne. Insert message
query_ref(vado(Y,montagna),1,anne).

past(inform(query_ref(vado(montagna,fdvar_4),1), v
alues(vado(domani,montagna)),pippo), 59946,
pippo).
54
Inform (FIPA)

• Latto di chiedere ad un agente se conosce la
  proposizione contenuta nellagree.
• La sintassi di questa primitiva prevede che la
  proposizione di cui si domanda la conoscenza sia
  un atomo ground.
• La sintassi da modulo utente è
• inform(Proposizione,Agente_sende
  r)

55
Refuse (FIPA)

• Indica latto di rifiutare qualcosa o una data
  azione.
• Questo comando,interno al protocollo di
  comunicazione, ha la seguente sintassi
• refuse(Cosa_rifiutata,Agente_sender)
• Il codice del refuse prevede, dopo il check, la
  memorizzazione come evento del passato del
  rifiuto.

56
Confirm (FIPA)

• Lagente sender informa il receiver che una data
  proposizione è vera. La proposizione viene
  asserita come evento del passato.
• A livello di codice abbiamo il richiamo al check
  e lasserzione, come evento del passato, della
  proposizione contenuta nel confirm.
• La sintassi del confirm da modulo utente è
• confirm(Proposizione,Agente_sende
  r)

57
Confirm (FIPA)

New message Insert name of addressee pippo.
Insert Language
italian. Insert
Ontology .
Insert From anne.
Insert message confirm(asserisci(questo),anne
).
past(asserisci(questo), 255677, anne).

58
Disconfirm (FIPA)

• Lagente sender informa il receiver che una data
  proposizione è falsa. La proposizione viene
  ritratta da evento del passato.
• A livello di codice abbiamo il richiamo al check
  e la ritrazione, da evento del passato, della
  proposizione contenuta nel disconfirm.
• La sintassi del disconfirm da modulo utente è
• disconfirm(Proposizione,Agente_sender)

59
Confirm (FIPA)

New message Insert name of addressee pippo.
Insert Language
italian. Insert
Ontology .
Insert From anne.
Insert message disconfirm(asserisci(questo),a
nne).
past(asserisci(questo), 255677, anne).

60
Agree

• Indica latto di domandare ad un altro agente
  se conosce un fatto.
• A livello di codice abbiamo il richiamo al
  check ed al livello del meta ragionamento.
• La sintassi del disconfirm da modulo utente è
• agree(Proposizione,Agente_sender)

61
Agree

New message Insert name of addressee pippo.
Insert From anne.
Insert message
confirm(asserisci(questo),anne). New
message Insert name of addressee pippo.
Insert From anne.
Insert message
agree(asserisci(questo),anne).
send_message_to(anne, inform(agree(asserisci(quest
o)),values(yes),pippo),italian,)

past(inform(agree(asserisci(questo)),values(yes),p
ippo), 53827, pippo).
62
Invio di messaggi FIPA

• Parallelamente alla funzionalità di ricevere
  messaggi seguendo il protocollo FIPA, gli agenti
  Dali sono in grado di inviare messaggi aderenti
  al suddetto protocollo.
• La sintassi dellinvio del query_ref è
• send(To,query_ref(X,N,Ag))-
• tell(To,Ag,query_ref(X,N)),send_m(To,query_ref(X,
  N,Ag)).

63
Generare un agente Dali

• In questa nuova versione di DALI si è deciso di
  attivare un agente per mezzo di un file di testo
  che contiene i dati necessari.
• La stringa rende anche automatico il processo di
  attivazione di un agente permettendo di
  rigenerare automaticamente il processo o di
  delegare il compito ad altre entità software.
• agent('dali examples/agent',pino,'pino_ontolog
  y.txt',italian,lira,communication_fipa,communicat
  ion,liraMode(local,classpath,host,port,agent_name
  ,ClassJavaName)).

64
esempi
65
The Dali Interpreter

• Initialization of server
• Aprire la shell di Sicstus Prolog e caricare il
  file active_server.pl.
• Initialization of user module
• Aprire una shell di Sicstus Prolog e caricare il
  file active_user.pl.Il modulo si mettera in
  attesa dei dati relativi allinvio di un
  messaggio. I dati richiesti saranno
• Il nome dellagente destinatario del messaggio
• Il linguaggio in cui viene espresso il contenuto
  del messaggio italian, english,...
• Lontologia adottata
• Il nome dellagente che invia il messaggio
• Il contenuto del messaggio

Insert name of addressee pippo. Insert
Language italian. Insert Ontology . Insert
From pino. Insert messagesend_message(rain,pin
o).
Insert name of addressee pippo. Insert
Language italian. Insert Ontology
piove,cade_acqua. Insert From pino. Insert
messagesend_message(rain,pino).
66
The Dali Interpreter

• La sintassi dei messaggi corrrisponde a quella
  del protocollo adottato FIPA nel nostro caso!
• Qualche esempio
• - Chiamare una regola reattiva con il
  send_message
• 
  send_message(arriva(X),gino)
• - Comunicare un fatto ad un agente con il
  confirm
• 
  confirm(piove(oggi),pip
  po).
• Proporre una azione con il propose
• 
  propose(vai_alla_stazione,mamma).
  
• Invocare una procedura allinterno del programma
  logico con execute_proc
• 
  execute_proc(aggiorna(Y),pluto).

67
The Dali Interpreter

Inizializzazione di un agente Dali Aprire una
shell di Sicstus Prolog e caricare il file
lida.pl. Linterprete chiederà il nome del file
di inizializzazione dell agente Dali Inserire
il percorso ed il nome del file di
inizializzazione pippo.txt. Il file di
inizializzazione è un file di estensione txt che
contiene la stringa con i dati dellagente Dali
da generare agent('dali demo/anne',anne,'anne_on
tology.txt',
italian,communicatio
n,communication_fipa,no).
68
Dali examples
File name anne.txt
Directives for the interpreter action(go_by_car,no
rmal). action(take_the_bus,normal). action(ask_sus
an_to_join,normal). action(copri(_172364),normal).
external_event(invitation,normal). external_event
(piove,normal). external_event(arriva,normal). pas
t_event(invitation,20). past_event(piove,20). past
_event(arriva,20). past_event(go_by_car,20). past_
event(take_the_bus,20). past_event(ask_susan_to_jo
in,20). past_event(copri(_171544),20). internal_ev
ent(go_by_car,3,forever,true,until_cond(past(go_by
_car))).
Anne invitationEgtonce(go_out). go_out-go_by_carA
. go_by_carltclause(car_available,_). go_out-take
_the_busA. go_by_carIgtask_susan_to_joinA.
agent('dali demo/anne',anne,'anne_ontology.txt', i
talian,communication,communication_fipa,no).
69
Dali examples
File name anne.txt
USER MODULE
New message Insert name of addressee
anne. Insert Language italian. Insert
Ontology . Insert From pino. Insert
message send_message(invitation,pino).
make(take_the_bus,_)
New message Insert name of addressee
anne. Insert Language italian. Insert
Ontology . Insert From pino.Insert
message confirm(car_available,pino). New
message Insert name of addressee Insert
message send_message(invitation,pino).
make(go_by_car,_) make(ask_susan_to_join,_)
70
Dali examples
File name animal.txt
Directives for the interpreter
Animal predator_attacksE(X)gtonce(try_to_escape(X)
). try_to_escape(X)-flyA(X). try_to_escape(X)-ru
nA(X). fly(X)ltbirdP(X),not(abnormalP(X)).
action(fly(_228740),normal). action(run(_228740),n
ormal). external_event(predator_attacks,normal). p
ast_event(predator_attacks,20). past_event(fly(_22
8039),20). past_event(run(_228039),20).
New message Insert name of addressee pippo.
Insert
Language italian.
Insert Ontology .
Insert From pino.
Insert message
confirm(bird(penguin),pino). New
message Insert name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From pino.
Insert message confirm(abnormal(penguin),p
ino).
make(run(penguin),_)
make(fly(duck),_)
71
Dali examples
File nameshoes.txt
Planner goEgtput_shoesG. put_shoes-put_right_sho
eG,put_left_shoeG,
right_shoe_onP,left_shoe_onP. put_shoesIgtleft_and
_right_shoes_onA,
retractall(past(_,_,_)). put_right_shoe-put_righ
t_sockG,right_sock_onP. put_right_shoeIgtright_sho
e_onA. put_left_shoe-put_left_sockG,left_sock_on
P. put_left_shoeIgtleft_shoe_onA. put_right_sock
-have_right_sockP. put_right_sockIgtright_sock_onA
. put_left_sock-have_left_sockP. put_left_sockI
gtleft_sock_onA.
Directives for the interpreter
action(left_and_right_shoes_on,normal). action(rig
ht_shoe_on,normal). action(left_shoe_on,normal). a
ction(right_sock_on,normal). action(left_sock_on,n
ormal). external_event(go,normal). past_event(go,2
0). past_event(put_shoes,20). past_event(put_right
_shoe,20). past_event(put_left_shoe,20). past_even
t(put_right_sock,20). past_event(put_left_sock,20)
. past_event(left_and_right_shoes_on,20). past_eve
nt(right_shoe_on,20). past_event(left_shoe_on,20).
past_event(right_sock_on,20). past_event(left_soc
k_on,20). internal_event(put_shoes,3,forever,true,
until_cond(past(put_shoes)))...
72
USER MODULE
Dali examples
New message Insert name of addressee
pippo. Insert Language italian. Insert
Ontology . Insert From pino.
Insert message
confirm(have_left_sock,pino). New message Insert
name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From pino.
Insert message confirm(have_right_sock,pino).
New message Insert name of addressee pippo.
Insert Language italian.
Insert Ontology .
Insert From pino.
Insert message
send_message(go,pino).
make(right_sock_on,_) make(right_shoe_on,_) make(l
eft_sock_on,_) make(left_shoe_on,_) make(left_and_
right_shoes_on,_)
73
Dali examples
New message Insert name of addressee
anne. Insert Language italian.
Insert Ontology . Insert
From pino. Insert message
send_message(grandina,pino). New message Insert
name of addressee anne.
Insert Language italian.
Insert Ontology grandina. Insert From
pino. Insert message
send_messagee(cade_grandine,pino). New
message Insert name of addressee anne.
Insert Language italian.
Insert Ontology
grandina. Insert From
pino. Insert
message send_message(cade_grandine,pino).
Anne e lontologia grandinaEgtcompro_un_ombrelloA
, corro_a_casaA.
make(compro_un_ombrello,34890) make(corro_a_casa,3
4890) Eliminated messagenot exists meta_rule for
send_messagee(go,pino) Frompinonb-kasko-eagle1
032 make(compro_un_ombrello,119343) make(corro_a_
casa,119343)
74
Dali examples
PLUTO
PIPPO
File name pluto.txt
File name pippo.txt
-dynamic isa/3. conosciE(X)-messageA(pluto,agree
(conosco(X),1,pippo)). isa(ama(pippo,iole),45566,
pippo).
amaE(X)- messageA(pippo,query_ref(ama(X,Y),1,plut
o)).
send_message_to(pippo,query_ref(ama(pippo, fdvar_2
),1,pluto),italian,)
send_message_to(pluto, inform(query_ref(ama(pippo,
fdvar_2),1), values(ama(pippo,iole)),pippo),ital
ian,).
75
Dali examples
PLUTO
PIPPO
File name pluto.txt
File name pippo.txt
-dynamic isa/3. conosciE(X)-messageA(pluto,agree
(conosco(X),1,pippo)). isa(ama(pippo,iole),45566,
pippo).
amaE(X)- messageA(pippo,query_ref(ama(X,Y),1,plut
o)).
send_message_to(pippo,inform(agree(conosco(iole)),
values(no),pluto),italian,) send_message_to(pipp
o,inform(agree(conosco(iole)),values(yes),pluto),i
talian,)
send_message_to(pluto,agree(conosco(iole),pippo),i
talian,) send_message_to(pluto,agree(conosco(iol
e),pippo),italian,)
New message Insert name of addressee pluto.
Insert message
confirm(conosco(iole),pippo).
76
Insert name of addressee anne.

Insert Language italian.
Insert
Ontology .
Insert From
pippo.
Insert message
propose(take_the_bus,pippo). New message Insert
name of addressee anne.
Insert Language italian.
Insert Ontology .
Insert From pippo.
Insert message propose(take_the_bus,piove,pi
ppo). New message Insert name of addressee
anne. Insert
Language italian.
Insert Ontology .
Insert From pino.
Insert
message confirm(piove,pino).
Dali examples
ANNE
PIPPO
Eliminated messagenot exists meta_rule for
propose(take_the_bus,pippo) Frompipponb-kasko-ea
gle1032 send_message_to(pippo,reject_proposal(tak
e_the_bus,,anne),italian,) send_message_to(pip
po,accept_proposal(take_the_bus,,anne),italian,
)
77
Dali examples
New message Insert name of addressee anne.
Insert Language
italian. Insert Ontology .
Insert From pippo.
Insert message propose(take_the_bus
,piove,pippo).New message Insert name of
addressee anne.
Insert Language italian.
Insert Ontology .
Insert From pippo.
Insert message
propose(go_by_car,piove,pippo).
ANNE
PIPPO
send_message_to(pippo,accept_proposal(take_the_bus
,,anne),italian,) make(take_the_bus,224766) se
nd_message_to(pippo,accept_proposal(go_by_car,,a
nne),italian,) send_message_to(pippo,failure(go_
by_car,motivation(false_conditions),anne),italian,
)
78
Dali examples
New message Insert name of addressee anne.
Insert Language
italian. Insert
Ontology .
Insert From pippo.
Insert message confirm(car_available,pippo). N
ew message Insert name of addressee anne.
Insert Language italian.
Insert Ontology .
Insert From pippo.
Insert message propose(go_by_car,pi
ove,pippo).
ANNE
PIPPO
Anne
send_message_to(pippo,accept_proposal(go_by_car,
,anne),italian,) make(go_by_car,312094) make(ask
_susan_to_join,312109)
Pippo
past(failed_action(go_by_car,motivation(false_cond
itions),anne), 197047, anne). past(accepted_propos
al(go_by_car,,anne), 240344, anne).