Università degli Studi di L’Aquila

1. Università degli Studi di L’Aquila 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 all’evento Funzione: si innesca la reazione all’evento secondo le direttive specificate dalla regola reattiva contenuta nel programma logico DALI. suona_la_svegliaE:>mi_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_qualcunoI:>mi_vestoA. mi_vesto:< sono_svestitoP. suona_il_campanelloE:>apro_la_portaA Stage 2:dopo la reazione, l’ agente e’ capace di ricordare l’evento esterno. Funzione: ragionamento su cosa e’ accaduto nel passato. sono_pigro:-suona_la_svegliaP not(mi_alzoP) sono_pigroI:> prendo_un_giorno_di_ferieA 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 dall’agente alla quale l’agente reagisce similarmente ad un evento esterno! Le conclusioni interne scatenano la proattivita’ dell’agente! • Il “comportamento” di un evento interno e’ determinato dalle direttive dell’utente: • ogni quanto tempo tentare l’evento; • 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 l’agente ha reagito,azioni compiute,conoscenza,…) sono tutte true, si scatena la reazione Stage2:dopo la reazione, l’agente e’ capace di ricordare l’evento interno cucino:-acceso_gasP, metto_pentola_sul_gasP, minuti_cottura(25),passati_minuti(25). cucinoI:>tolgo_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):-findall(str(AT,D),clause(log(_,_,_,AT,_,_,D,_),_),L), length(L,Lu),Lu>5,remove_duplicates(L,L1), member(M,L1),arg(1,M,H1),arg(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),Lu>5,remove_duplicates(L,L1), member(M,L1),arg(1,M,H1),arg(2,M,Time),intervalloP(_).sintomo1I(X,H1,Time):>write(sintomo_uno(X,H1,Time)),nl.sintomo2(T):-carica_fileP(_,_),datime(T),arg(4,T,H),H>=9.sintomo2(T):-carica_fileP(_,_),datime(T),arg(4,T,H),H=<8.sintomo2I(T):>write(sintomo_due(T)),nl.sintomo3(X):-carica_fileP(X,_),datime(T),arg(4,T,H),H<9,H>8.sintomo3(_):-intervalloP(_),datime(T),arg(4,T,H),H<9,H>8.sintomo3I(X):>write(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-2=<M1,M1<M+3.attacco1I(P,date(A,Me,G),time(O,M)):>clause(agent(Ag),_), messageA(manager,send_message(attacco1(P,date(A,Me,G),time(O,M,00)),Ag)).attacco2(X,H,D):-sintomo1P(X,H,D).attacco2I(X,H,D):>clause(agent(A),_),trasf(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,_):>clause(agent(A),_), messageA(manager,send_message(attacco3(H,D,_),A)).

7. Dali: i goals “” • Dali possiede due tipi di goals: • goals che l’agente tenta di perseguire: • Sono legati agli eventi interni. Quando un agente invoca un goal, attiva l’evento interno corrispondente che tenta le precondizioni. Se quest’ultime diventano vere, si attiva il piano. • goals che l’agente 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. goE:>put_shoesG. put_shoes:-put_right_shoeG, put_left_shoeG, right_shoe_onP,left_shoe_onP. put_shoesI:>left_and_right_shoes_onA, retractall(past(_,_,_)). put_right_shoe:-put_right_sockG,right_sock_onP. put_right_shoeI:>right_shoe_onA. put_left_shoe:-put_left_sockG,left_sock_onP. put_left_shoeI:>left_shoe_onA. put_right_sock:-have_right_sockP. put_right_sockI:>right_sock_onA. put_left_sock:-have_left_sockP. put_left_sockI:>left_sock_onA.

8. STRIPS e DALI: planning “L’idea dello STRIPS planner e’ dividi e conquista:per 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_supermercatoI:>sono_al_supermercatoA. vai_alla_ferramenta:-sono_al_supermercatoP. vai_alla_ferramenta:-sono_a_casaP. vai_alla_ferramentaI:>sono_in_ferramentaA. vai_a_casa:-sono_in_ferramentaP. vai_a_casa:-sono_al_supermercatoP. vai_a_casaI:>sono_a_casaA. compra_banana:-sono_al_supermercatoP. compra_bananaI:>compro_bananaA. ... compra_chiodi:-sono_in_ferramentaP. compra_chiodiI:>compro_chiodiA. vaiE:>sono_a_casaA,compra_tuttoG. compra_tutto:-procura_bananaG,procura_latteG,vai_a_casaG, pago_bananaP,pago_latteP,sono_a_casaP. compra_tutto:-procura_chiodiG,vai_a_casaG,pago_chiodiP,sono_a_casaP. compra_tuttoI:>acquisto_tuttoA. procura_banana:-vai_al_supermercatoG,compra_bananaG, sono_al_supermercatoP,compro_bananaP. procura_bananaI:>pago_bananaA. ... procura_chiodi:-vai_alla_ferramentaG,compra_chiodiG, sono_in_ferramentaP,compro_chiodiP. procura_chiodiI:>pago_chiodiA.

9. suona_il_campanelloE(gino)):>apro_la_portaA, messageA(gino,send_message(ciao,pippo)). 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. L’interprete 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 l’azione viene rimessa in coda in attesa che il contesto la renda ammissibile. Se questo non accade l’agente 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. Eventi esterni e del presente Eventi interni Azioni Goals EVENTI DEL PASSATO Reazione 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’ anch’esso definito dalle direttive dell’utente: • forever • fino ad un certo tempo (until_time) • fino a quando si verifica una data condizione (until_cond) sunny_weatherE :> open_the_windowA. rainy_weatherE:>close_the_windowA open_the_window:<close_the_windowP close_the_window:< open_the_windowP

11. LINDA PRIMITIVE COMMUNICATION Agente DALI 3 Agente DALI 2 Agente DALI n Agente DALI 1 Dali: la architettura multiagente GUSCIO DALI Elabora,estrae e gestisce gli eventi, le azioni, le regole e la comunicazione dell’agente DALI in esso contenuto PROGRAMMA LOGICO DALI Descrive il comportamento dell’agente 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,TimeStamp,SeqId,AckContent), wait_reply(DestAgent,TimeStamp,SeqId,VarName,VarValue),…]. [go_by_car,take_the_bus,ask_susan_to_join,aiuto(X), message(To,set(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(var_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([]),forever).

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. COORDINAZIONE Cooperazione Competizione Planning Negoziazione 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 l’interpretazione dei messaggi

21. Messaggi Filtro comunicazione Filtro comunicazione Metaragionamento Metaragionamento Interprete Interprete Progr. Logico Dali Progr. Logico Dali Nuova architettura degli agenti Dali L’architettura 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 dall’utente 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 dall’utente. Ciò evita di dover cambiare ogni volta il codice dell’interprete. told(Ag,tipo_messaggio(_)):- constraint1,constraint2,...,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 all’interno della stessa lingua, non tutti utilizzano le stesse parole per esprimere un dato concetto. • In questo caso si può istruire l’agente 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. L’utilizzo di una ontologia Supponiamo di avere la seguente regola reattiva. caso1E(X):>azione1A(X),azione2A(X). • Se l’agente sà che caso1 è semanticamente equivalente a caso2, può rispondere all’evento esterno caso2 pur conoscendo soltanto caso1. • Che caso1 sia equivalente a caso2 può essere una informazione data a run-time dall’agente che invia il messaggio al destinatario oppure può essere contenuto nell’ ontologia associata all’agente 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 dell’interprete vero e proprio. • Tale procedura è contenuta nel file ‘communication.txt’ e può essere modificata dall’utente senza intaccare il codice dell’interprete. Ciò permette di aggiungere potenzialità a livello di meta-ragionamento in un agente senza avere conoscenze troppo approfondite sull’intero sistema.

31. Come è fatto il meta-ragionamento… meta(Initial_term,Final_term,Agent_Sender):-clause(agent(Agent_Receiver),_), functor(Initial_term,Functor,Arity),Arity=0, ((ontology(Agent_Sender,Functor,Equivalent_term); ontology(Agent_Sender,Equivalent_term,Functor)); (ontology(Agent_Receiver,Functor,Equivalent_term); ontology(Agent_Receiver,Equivalent_term,Functor))), Final_term=Equivalent_term. meta(Initial_term,Final_term,Agent_Sender):-functor(Initial_term,Functor,Arity),Arity=2, symmetric(Functor),Initial_term=..List, delete(List,Functor,Result_list), reverse(Result_list,Reversed_list), append([Functor],Reversed_list,Final_list), Final_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,fdvar_6),1), motivation(no_values),pippo),italian,[]) send_message_to(anne, inform(query_ref(ama(gina,fdvar_7),1), values([ama(pippo,gina)]),pippo),italian,[])

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 dell’interprete 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 l’agente 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):>once(try_to_escape(X)). try_to_escape(X):-flyA(X). try_to_escape(X):-runA(X). fly(X):<birdP(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(duck),pippo). make(run(penguin),96328) make(fly(duck),147492)

38. Propose (FIPA) • Identifica l’azione di sottomettere da parte di un agente ad un altro la proposta di compiere una certa azione date alcune precondizioni. • Le precondizioni sono inserite all’interno di una lista aggregata al messaggio. • La nuova strutturazione permette ad un agente Dali di chiedere ad un altro l’esecuzione di una singola azione, senza invocare alcuna regola, purchè questa azione sia conosciuta dall’agente e quindi inserita all’interno del programma logico.

39. Propose • L’accettazione della proposta di compiere una azione è legata alla verifica delle condizioni relative al messaggio. Se esse sono vere, l’agente che ha ricevuto il propose, invierà un messaggio all’agente proponente dicendo di accettare la proposta, altrimenti la rifiuterà. • Ogni azione Dali è sottoposta alla verifica delle precondizioni all’azione interne al programma logico. • La sintassi del propose per il modulo utente è: propose(Action,[condizione1,…,condizionen], Agente_sender)

40. Accept-proposal (FIPA) • Identifica l’atto di accettare la proposta di compiere una azione da parte di un agente ed è strettamente legato all’atto 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 nell’accettazione della proposta.

41. Reject-proposal (FIPA) • Identifica l’atto di rifiutare la proposta di compiere una azione da parte di un agente ed è strettamente legato all’atto 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 l’atto 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_fallita,motivation(Motivo), Agente_sender))

43. Propose dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:<have_a_phoneP. ask_for_help:-screamA. New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: pippo. Insert message |: propose(call_police,[near_home],pippo). send_message_to(pippo, reject_proposal(call_police,[], pippo),italian,[])

44. Propose dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:<have_a_phoneP. ask_for_help:-screamA. 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, motivation(false_conditions), pippo),italian,[])

45. Propose dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:<have_a_phoneP. ask_for_help:-screamA. … |: 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 dell’arrivo 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) dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:<have_a_phoneP. ask_for_help:-screamA. 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 all’interno 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),pippo). 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),pippo). pippo Ontologia