DALI Handbook

DALI Multiagent System
Handbook and Examples

How to create and use a DALI Agent:
Summary
 How the DALI Interpreter starts

 (provided you have installed Sicstus Prolog)
 How to create an agent:

 the DALI initialization file
 How to write a DALI logic program
 Architecture of the DALI Interpreter
 Examples
How the DALI Interpreter starts
active_dali.pl/
agent.bat
active_server.pl/
server.bat
...
active_user.pl/
user.bat
active_dali.pl/
agent.bat
In order to start the DALI Multiagent System it’s necessary to activate the server,
next the user module, finally one or several DALI agents.
How the Server starts active_server.pl/
active_server.exe
active_user.pl
DALI
active_server.pl
program
file_dali.txt
active_dali_wi.pl
We can activate the DALI server either by invoking the the executable file
‘server.bat’ or, via the Sicstus Prolog shell, by loading the file ‘active_server.pl’.
This is the command to load the server, that you can fond in the demo directory:
load_files('C:/Programmi/SICStus Prolog 3.11.1/bin/demo/active_server.pl').

How the User Module starts active_user.pl/
active_user.exe
We can activate the DALI user module either by using the ‘user.bat' executable
file or, via the Sicstus Prolog shell, by loading the file ‘active_user.pl’.
This is the command to load the file that you can find in the demo directory:
load_files('C:/Programmi/SICStus Prolog 3.11.1/bin/demo/active_user.pl').
The user module opens a user window for communicating with DALI agents, as
explained later on.
The name of the Receiver agent
The language of the message
The list of terms useful to interprete

a message
The name of the Sender agent
The content of the message

active_dali.pl/
How the DALI Interpreter starts agent.bat
We can activate the DALI Interpreter either by using the executable file
‘agent.bat’.
If the paths of the initialization file and of the current installation of Sicstus
Prolog set in the batch file are right, the agent will be activated:
.................. Actived Agent ...................
Initialization file
help.txt
initialization_files
dali
active_user.pl
active_server.pl
program
DALI logic program
help.txt
In this way it is possible to activate several DALI
agents having different names and logic programs.
active_dali_wi.pl
DALI initialization file
The initialization file <init>.txt must be in the directory
“initialization_dali_files”, and contains the following
informations:
 The name of the file that contains the DALI logic program;
 The name of the agent;
 The adopted ontology ('no' if no ontology is used);
 The adopted language (Italian,English,…) in the
communication acts;
 The name of the file containing the tell/told communication
constraints;
 The name of the communication library;
 The agent’s abilities ( kind of work, hobbies,…)
These parameters are grouped in a string with prefix ‘agent’,

according to the above order, with the syntax exemplified
below.
DALI initialization file: example
Example: content of the initialization file
agent('demo/program/italian',gino,
'../onto/gino.onto',italian,
['demo/communication'],
['demo/communication_fipa'],[tourist]).
The path is specified starting from the directory where the

interpreter is.
DALI initialization file: example
Precisely:
‘gino’ is the name of the agent,

‘italian.onto’ is the ontology file in the directory ‘onto’
and Italian is the language spoken by the agent.
Finally, ‘communication’ is the file ‘communication.con’ in the

main directory containing the tell/told constraints and
‘communication_fipa’ is the library with the fipa communication’s
primitives.
The last parameter suggests that the agent is a tourist.
At this point, we can write a DALI logic program with .txt

extension and put it in the directory program.
Generate a DALI initialization file
In the initialization string (see above) we put the initialization file under the
directory 'initialization_dali_files' and the DALI logic program file
file_dali.txt’ in the directory program:
communication.con
DALI
communication_fipa.txt
ONTO
file_dali.onto
program
file_dali.txt
active_dali_wi.pl
How the User Module works active_user.pl/
active_user.exe
The user module allows the user to communicate with an existing DALI
agents, by means of the DALI primitive send_message(Content,Sender) where
Sender=user and Content is an external event we want the agent to perceive.
will ask the following arguments:
Insert name of addressee

The name of the Receiver agent
|: pippo.
Insert From The name of the Sender agent

|: user.
Insert message The content of the message

|: send_message(danger,user).
How to use Ontologies in the User Module
(simple way, to be further developed)
If we have for instance, in the DALI logic program, the following reactive rule:
dangerE:>once(ask_for_help).
ask_for_help:-call_policeA.
call_police:<have_a_phoneP.
ask_for_help:-screamA.
If we tell the agent that ‘pericolo’ is equivalent to ‘danger’, we can then send
the message send_message(pericolo,user).

|: pippo.
Insert From
|: user.
Insert message
|: send_message(pericolo,user).
Write DALI logic program
A Dali program is a file txt whose content is a DALI program.
Now we shortly recall the main features of this language by writing a DALI
agent:
External events:
The external events are syntactically indicated by the postfix E. When an

event enters the agent from its external world, she can perceive it and
decide to react. The reaction is defined by a reactive rule which has in its
head that external event.
The special token :>, used instead of :-, indicates that the reactive rule
performs forward reasoning.
If we write in the txt file this simple reactive rule:
alarm_clock_ringsE:>stand_upA
the agent observes the following behavior. We use the user module to
send to the agent the external event alarm_clock_rings.
Write DALI logic program:External Event
|: pippo.
Insert From Nome file: alarm.txt
|: user.
Insert message
|: send_message(alarm_clock_rings,user).
.................. Actived Agent ...................
make(stand_up)
The DALI agent will do the action contained in the body

of the reactive rule.
Write DALI logic program:Internal Event
Internal events:
The internal events define a kind of individuality of a DALI agent, making

her proactive independently of the environment, of the user and of the
other agents, and allowing her to manipulate and revise her knowledge.
An internal event is syntactically indicated by the postfix I, and its
description is composed of two rules. The first one contains the
conditions (knowledge, past events, procedures, etc.) that must be true
so that the reaction (in the second rule) may happen.
If we write in the txt file those two rules:
i_am_lazy:-alarm_clock_ringsP
not(stand_upP)
i_am_lazyI:> i_take_a_vacation_dayA.
the agent exhibits the following behavior. We use the user module to
send to the agent the past event alarm_clock_ringsP but this past event
could be the past form of the external event as specified in the previous
paragraph, and arrived before.
Write DALI logic program:External Event
|: pippo.
Insert From Nome file: alarm_clock.txt
|: user.
Insert message
|: confirm(alarm_clock_rings,user).
.................. Actived Agent ...................
make(i_take_a_vacation_day)
The DALI agent will make the action contained in the reaction
of the internal event.
Write DALI logic program:Present Event
Present events:
When an agent perceives an event from the external world it does not
necessarily react to it immediately: she has the possibility of reasoning on the
event, before (or instead of) triggering a reaction. Reasoning also allows a
proactive behavior. In this situation, the event is called present event and is
indicated by the suffix N.
arrives_someone:-bell_ringsN.
arrives_someoneI:>get_dressedA.
get_dressed:< get_undressedP.
bell_ringsE:>open_the_doorA.
In this case, when we send the external event bell_rings to the agent,
she makes the actions get_dressed and open_the_door if the internal
event has been processed before the external event. Else, she does only
the action open_the_door. In small DALI programs is unlikely to observe
the reaction to the internal event, because the processing of the external
events is faster and the interpreter, after the action open_the_door,
erases the reaction to the internal event.
Write DALI logic program:Present Events
|: pippo.
Insert From Nome file: wear.txt
|: user.
Insert message
|: send_message(bell_rings,user).
.................. Actived Agent ...................
make(open_the_door)
make(open_the_door)
make(open_the_door)
make(open_the_door)
make(get_dressed)
make(open_the_door)
make(open_the_door)
make(open_the_door)
make(open_the_door)
Write DALI logic program:Actions
Actions:
 Simple actions:
The action in the DALI program is specified as actionA.
For example i_go_to_bedA, i_take_the_busA, …
When the agent does an action, on the prolog shell you can
observe make(action).
 Messages as actions:
From a DALI program, a message can be sent by writing:
messageA(To, Content)
where To is the name of the agent that must receive the

communication act and Content is the DALI/FIPA primitive.
We now describe the primitives used in a DALI program.

Sender is the agent that sends the message.
o send_message(External_event, Sender)
this primitive is used to call an external event within a reactive
rule;
o confirm(Assertion, Sender)
this primitive is used to assert a fact within a DALI agent;
o disconfirm(Assertion, Sender)
this primitive is used to retract a fact within a DALI agent;
o propose(Action, List_Conditions,Sender)
this primitive is used to propose an agent to do an action
contained within a DALI program. The agent can respond by
accepting to do the action (accept_proposal) or by rejecting the
proposal (reject_proposal) if the conditions in the message are
false. When the agent decides to make the action, she verifies if
the conditions of the action rule are true. In this case, the agent
does the action or else she sends to the other agent a failure
message.
o execute_proc(Head, Sender)
this primitive is used to invoke the head of a generic rule
(procedure) in the DALI program;
o query_ref(Fact, N, Sender)
this primitive is used to answer an agent on some information
about a not ground Fact. N is the number of the requested
matchings;
o agree(Fact, Sender)
this primitive is used to answer an agent knowing a ground
Fact;
o cancel(Action, Sender)
this primitive is used to communicate to an agent to cancel a
requested action. Also in this case, it is difficult to see the effect
of this primitive because the agent does immediately the action.
To see the effect, the queue of actions must contain several
items.
Write DALI logic program: Goals
A goal is an objective that an agent must reach. In the DALI language, a goal is
a particular internal event that the interpreter begins to attempt when it is
invoked. The goal has a postfix G.
How it works:
Environment State
...,goal1G,...
goal1:- condition11,...,condition1k
Goal Plan to reach a goal
subgoal11G,...,subgoal1NG,
PLANNER
subgoalP11,...,subgoalP1N.
...
goal1:-conditionm1,...,conditionmk
subgoalGm1,...,subgoalGmN,
subgoalP11,...,subgoalP1N.
Actions
goal1I:>action1,...,goal2G,...,actionk.
We consider a simple example: an agent must wear socks and shoes.
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.
Insert name of addressee Insert name of addressee Insert name of addressee
|: pippo. |: pippo. |: pippo.
Insert From Insert From Insert From
|: user. |: user. |: user.
Insert message Insert message Insert message
|: confirm(have_left_sock,user). |:confirm(have_right_sock,user). |: send_message(go,user).
Nome file: shoes.txt

.................. Actived Agent ...................
make(right_sock_on)
make(right_shoe_on)
make(left_sock_on)
make(left_shoe_on)
make(left_and_right_shoes_on)
Write DALI logic program: Past events
Past events:
A past event, indicated by the suffix P, is:
o an external or internal event after a reaction;

o an executed action;
o a reached goal or subgoal;
o a fact communicated using a confirm primitive.

|: pippo.
Insert From past(rain,timestamp, user)
|: user.
Insert message is recorded within DALI shell.
|: confirm(rain,user). This past event is called using the
string with postfix P. For example,
rainP.
The architecture of a DALI agent
Pre-processing file.txt
Communication
module
Processing
Events
Actions
Goals
Communication
module
The files that the interpreter generates from
DALI txt file
file.ple
file.txt file.plf
file.pl
The DALI interpreter generates some auxiliary files for each agent. These files
are put in the same directory as the txt DALI file.
A simple txt DALI file
We use this txt file to show how the interpreter works creating ple, plf and
pl files. In order to show the ‘naming’ process we use a new example
containing variables.
External event
Reaction rule dangerE:>once(ask_for_help).

ask_for_help:-call_policeA. Past event
Action rule call_police:<have_a_phoneP.
remain_at_home:-dangerP,call_policeP.
remain_at_homeI:>go_to_bathroomA,
close_the_doorA.
go_out:-dangerP,screamP.
go_outI:>go_to_neighbourA. Action
Internal event
What the Interpreter records in the ple file
[danger]. External events
[remain_at_home,go_out,external_refused_action_propose(A,Ag),
refused_message(AgM,Con)]. Internal events
[call_police,scream,go_to_bathroom,close_the_door,go_to_neighbour,message(Ag,in
form(query_ref(X,N),values(L),A)),message(Ag,refuse(query_ref(variable),motivatio
n(refused_variables),A)),message(Ag,inform(query_ref(X,N),motivation(no_values),
A)),message(Ag,inform(agree(X),values(yes),A)),message(Ag,inform(agree(X),value
s(no),A))…].
[call_police]. Conditions
Actions
[]. Present events
[]. Goals to reach This file is used by the interpreter to

manage the behavior of the agent
through the classes of the events,
[]. Goals to test the actions, goals,…
The ‘naming’ of variables in the pl file
Dali pl program with reified variables
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))).
k
or
w
t er
Dali txt program re
rp
te
predator_attacksE(X):> In
once(try_to_escape(X)).
try_to_escape(X):-flyA(X). The interpreter generates a pl file
try_to_escape(X):-runA(X). where all rules are subjected to
fly(X):<birdP(X),not(abnormalP(X)). ‘naming’ process. All variables has
been transformed to costants using
the suffix ‘var_’.
The directives of plf file
We use this file to set some parameters that determine the behavior of
the agent relatively to external, internal, past events and actions .
Past event External event
We can decide how long or until We can decide if an external event

which condition a past event must must be processed with a normal
be kept in the memory of an agent: or high priority:
past_event(Event,Seconds). external_event(Event,normal).
(the past event is kept in memory some Seconds)
external_event(Event,high).
past_event(Event,forever).
(the past event is kept in memory forever)
past_event(Event,until(Cond)).
(the past event is kept in memory until Condition) Action
We can decide if an action

Action/Message must be processed with a normal
or high priority:
We can decide if to submit a message to tell
the tell check: action(Action,normal).
mod(Action, check). action(Action,high).

The directives of plf file
Now we examine the directives on internal events.
Internal event
We can set several parameters for an internal event in order to tune the
Interpreter behaviour:
o the frequency(seconds) with which the interpreter attempts the internal event;
o how many times the agent must react if the internal event is true (1,2,..,forever);
o when the agent must react: this parameter is ‘true’ if the reaction must happen
forever or else we can link the reaction to some past events belonging to body
of the first rule of the internal event; when the past event inside a ‘change list’
is modified the agent will be able to react again.
For example, if we have the internal event:
think:-rainP, go_outP,buy_umbrellaP.
thinkI:>open_the_umbrellaA.
we can set parameters as:

internal_event(think,3,1,change([rain,go_out]),forever).
o when/until when the interpreter must attempt the internal event:

o until_date(Date): till certain date;
o until_cond(Condition): when the Condition is false;
o forever: forever
Some directives of plf example file
action(call_police,normal). The action is put in the queue with normal priority

action(scream,normal).
action(go_to_bathroom,normal).
action(close_the_door,normal).
action(go_to_neighbour,normal).
external_event(danger,normal).
past_event(danger,20). This past event is kept in memory 20 seconds

past_event(remain_at_home,20).
past_event(go_out,20).
past_event(call_police,20). This internal event is attempted every 3 seconds
past_event(scream,20).
The agent will react forever
past_event(go_to_bathroom,20).
past_event(close_the_door,20). We specify no conditions
past_event(go_to_neighbour,20).
This internal event is attempted until the past
event remain_at_home becomes true
internal_event(remain_at_home,3,forever,true,until_cond(past(remain_at_home))).
internal_event(go_out,3,forever,true,until_cond(past(go_out))).
mod(message(_,inform(_,motivation(refused_message),_)),check).
This message is submitted to tell check

The Communication architecture
Incoming message
The message passes this level only if the
corresponding told rule is true.
TOLD CHECK
If the agent doesn’t know the content of
the message, she calls the meta-level and
META LEVEL uses the ontology and/or other properties
in order to understand the communication
act.
DALI INTERNAL
INTERPRETER
The message, submitted to tell check, is

sent only if the corresponding tell rule is
TELL CHECK true.
Outcoming message
The Told Check level
Incoming message
TOLD CHECK
Each DALI agent has a ‘con’ file, specified in the initialization file, that contains the
told/tell rules. These rules, external to interpreter, can be modified by the user.
The structure of a told rule is:
told(Sender,Content):-constraint 1,…,constraintn.
In this example, an agent receives a message, using the primitive send_message, only
if the Sender agent isn’t an enemy:
told(Ag,send_message(_)):-not(enemyP(Ag)).
A message that does not go through the told level is eliminated. The agent
Sender receives an inform message asserted as a past event.
The Meta-Level
META LEVEL
Each DALI agent uses an (optional) meta procedure written in the ‘communication.con’ file that
specifies how the entity can interprete an unknown message. This procedure can be
modified by the user.
In the initialization file the user can specify the ontology file that contains informations about the
ontology that the agent must use. This file contains informations about the location of the
ontology ( remember that ontologies are used by means of Sesame semantic repositories ).
"PREFIX rdfs:<http://www.w3.org/2000/01/rdf-schema#>". ← Prefixes of namespaces

"/openrdf-sesame/repositories/Ontology". ← Location of the ontology
"localhost:8080". ← Location of Tomcat ( On which runs SESAME ).
The Tell Check level
TELL CHECK
Outcoming message
The user can set the mod string in the plf file in order to submit a message to tell check.
In this case, the message is actually sent only if the corresponding tell rule is true.
The tell rules can be modified by the user.
The structure of a tell rule is:
tell(Receiver,Sender,Content):-constraint 1,…,constraintn.
In this example, an agent sends a message, using the primitive send_message, only
if she has a trust greater than 4 in the Receiver agent:
tell(To,_,send_message(_)):-trustP(_,To,N),N>4.
A message that does not go through the tell level is eliminated.

Examples – A dangerous situation…
One Agent!
Initialization file name: help.txt
DALI logic file name: help.txt
initalization_files help.txt
active_user.pl
DALI
active_server.pl
program
help.txt
active_dali.pl
DALI logic program help.txt
dangerE:>once(ask_for_help).
ask_for_help:-call_policeA.
call_police:<have_a_phoneP.
remain_at_home:-dangerP,call_policeP.
remain_at_homeI:>go_to_bathroomA,
close_the_doorA.
go_out:-dangerP,screamP.
go_outI:>go_to_neighbourA.
Run the DALI logic program

|: pippo.
Insert From
|: user.
Insert message
.................. Actived Agent ...................
make(scream)
make(go_to_neighbour)
New message If the agent has a phone…

|: pippo.
Insert From
|: user.
Insert message
|: confirm(have_a_phone,user).
New message
|: pippo.
Insert From she reacts differently!
|: user.
Insert message
.................. Actived Agent ...................
make(call_police)
make(go_to_bathroom)
make(close_the_door)
Examples – Error Recovery planning…
Two Agents!
Initialization file name: recovery.txt and sensor.txt
DALI logic file name: recovery.txt and sensor.txt
initalization_files sensor.txt
recovery.txt
active_user.pl
DALI
active_server.pl
sensor.txt
program
recovery.txt
active_dali.pl
DALI logic program recovery.txt
error_recovery(M,M1):-
go_rightP(_,M),goal(M),informP(reality(M,M1),sensor),M\=M1.
go_leftP(_,M),goal(M),informP(reality(M,M1),sensor),M\=M1.
go_forwardP(_,M),goal(M),informP(reality(M,M1),sensor),M\=M1.
error_recoveryI(M,M1):>recovery_errorA(M,M1),drop_pastA(reality(M,M1)).
reached_goal(M):-go_rightP(_,M),goal(M).
reached_goal(M):-go_leftP(_,M),goal(M).
reached_goal(M):-go_forwardP(_,M),goal(M).
reached_goalI(M):>clause(agent(Ag),_),
messageA(sensor,send_message(what_about_my_position(M,Ag),Ag)).
…
right(exit1,bank1).
right(exit2,bank2).
left(bank1,hospital1).
forward(bank2,bank1).
goal(hospital1).
DALI logic program sensor.txt
what_about_my_positionE(M,Ag):>once(examine_position(M,Ag,_)).
examine_position(M,Ag,M1):-
messageA(Ag,inform(reality(M,M1),sensor)),wrong_positionA(M,Ag).
message(_,inform(reality(M,M1),sensor)):<errorP(M,M1).
examine_position(M,Ag,_):-right_positionA(M,Ag).
Error Recovery planning
The environment…
Hospital
Bank2 Bank1
Exit2 Exit1
STATION
First situation: the agent exits from Exit1

Hospital
and goes to Hospital1
Bank2 Bank1
Exit2 Exit1 make(go_right(exit1,bank1))

make(go_left(bank1,hospital1))
confirm(i_am_at_exit(exit1),user)
STATION
Run the DALI logic programs recovery.txt and sensor.txt

|: pippo.
Insert From sensor
|: user.
Insert message .................. Actived Agent ...................
|: confirm(i_am_at_exit(exit1),user). make(right_position(hospital1,pippo))
robot pippo
.................. Actived Agent ...................
make(go_right(exit1,bank1))
send_message_to(sensor,send_message(what_about_my_position(hospital1,pippo),
pippo),italian,[])
Second situation: the agent exits from Exit2 Hospital

and goes to Hospital1
Bank2 Bank1
make(go_forward(bank2,bank1))
Exit2 Exit1 make(go_left(bank1,hospital1))
confirm(i_am_at_exit(exit2),user)
STATION

|: pippo.
Insert From sensor
|: user.
Insert message .................. Actived Agent ...................
|: confirm(i_am_at_exit(exit2),user). make(right_position(hospital1,pippo))
robot pippo
.................. Actived Agent ...................
send_message_to(sensor,send_message(what_about_my_position(hospital1,pippo),
pippo),italian,[])
Hospital1
Hospital1
?
Bank2 Bank1
Exit2 Exit1
Third situation: the agent thinks to make(recovery_error(hospital1,bank2))
be at Exit1 while really she is make(go_forward(bank2,bank1))
at Exit2. When she is at Hospital1/Bank2 STATION
a planner recognizes the error and
modifies the plan.
Examples – Error Recovery planning… (step1)

|: sensor.
Insert From
|: user.
Insert message
|: confirm(error(hospital1,bank2),user).
sensor
.................. Actived Agent ...................

Examples – Error Recovery planning… (step2)

|: sensor.
Insert From
|: user. sensor
Insert message
|: confirm(i_am_at_exit(exit1),user). .................. Actived Agent...............
send_message_to(pippo,inform(reality(hospital1,
bank2),sensor),italian,[])
make(wrong_position(hospital1,pippo))
robot pippo
.................. Actived Agent ...................
send_message_to(sensor,send_message(what_about_my_position(hospital1,pippo),pippo),
italian,[])
make(recovery_error(hospital1,bank2))
Examples – Informations and Meta-reasoning…
Two Agents!
Initialization file name: agent1.txt and agent2.txt
DALI logic file name: agent1.txt and agent2.txt
agent1.txt
agent2.txt
active_user.pl
DALI
active_server.pl
agent1.txt
program
agent2.txt
active_dali_wi.pl
We will consider two simple agents. We are interested in showing how
the communication primitives query_ref and agree use the meta-level
reasoning.
DALI logic program agent1.txt
rainE:-open_the_umbrellaA.
DALI logic program agent2.txt
i_am_illE:>go_to_family_doctorA.
We will communicate to agent1 the fact ama(james,julia). In the
ontology that the agent ‘pippo’ adopts there is the fact:
ontology(pippo,ama,love).
Run the DALI logic program agent1.txt

|: pippo.
Insert From
|: user.
Insert message
|: confirm(ama(james,julia),user).
Agent2 will ask agent1 about the james/julia love. The agent2 ‘pino’
will use the communication primitives query_ref and agree.
Run the DALI logic program agent2.txt
Insert the path and the name of the initialization file:

|: 'demo/agent2.txt'.
New message
|: pippo.
Insert From
|: pino.
Insert message
|: query_ref(ama(julia,Y),1,pino).
.................. Actived Agent ...................

send_message_to(pino,inform(query_ref(ama(julia,fdvar_9),1),values([ama(james,julia)]),
pippo),italian,[]) (fdvar is the reification method of the Sicstus Prolog)
New message
|: pippo.
Insert From
|: pino.
Insert message
|: query_ref(love(julia,Y),1,pino).
.................. Actived Agent ...................

send_message_to(pino,inform(query_ref(love(julia,fdvar_10),1),values([ama(james,julia)]),p
ippo),italian,[])
New message
|: pippo.
Insert From
|: pino.
Insert message
|: agree(love(julia,james),pino).
.................. Actived Agent ...................

send_message_to(pino,inform(agree(love(julia,james)),values(yes),pippo),italian,[])
Examples – Cooperation and Ontology…
Three Agents!
Initialization file name: italian.txt, english.txt and translator.txt
DALI logic file name: italian.txt, english.txt and translator.txt
translator.
english.txt
demo active_server.pl italian.txt
active_user.pl
translator.txt
progra
m english.txt
active_dali_wi.pl
italian.txt
DALI logic program italian.txt
questionE(Q,L,M):>agente(A,_,_,_), once(examine_question(Q,L,M,A)).
examine_question(Q,_,M,A):-messageA(M,send_message(know(Q,A),A)).
message(_,send_message(know(Q,A),A)):<clause(know(Q,A),_);knowP(Q,A).
examine_question(Q,L,M,A):-
messageA(translator,send_message(translate(Q,L,M,A),A)).
message(translator,send_message(translate(_,L,_,_),_)):< L=english.
messageA(M,send_message(not_know(Q,L,A),A)).
message(_,send_message(not_know(_,L,_),_)):< L=italian.
know(io,gino).
know(amo,gino). ITALIAN
know(odio,gino).
DALI logic program italian.txt
questionE(Q,L,M):>agente(A,_,_,_),
once(examine_question(Q,L,M,A)).
examine_question(Q,_,M,A):-
messageA(M,send_message(know(Q,A),A)).
message(_,send_message(know(Q,A),A)):<clause(know(Q,A),_);k
nowP(Q,A).
message(translator,send_message(translate(_,L,_,_),_)):<
L=english.
…
ITALIAN
know(io,gino).
know(amo,gino).
know(odio,gino).
DALI logic program english.txt
questionE(Q,L,M):>agente(A,_,_,_),
once(examine_question(Q,L,M,A)).
examine_question(Q,_,M,A):-
messageA(M,send_message(know(Q,A),A)).
message(_,send_message(know(Q,A),A)):<clause(know(Q,A),_);k
nowP(Q,A).
message(translator,send_message(translate(_,L,_,_),_)):<
L=italian.
know(i,susy).
know(love,susy).
know(hate,susy).
know(you,susy).
DALI logic program translator.txt
translateE(Q,L,M,A):>once(examine_translation(Q,L,M,A)).
examine_translation(Q,_,M,A):-clause(translated(Q,Tr),_),
messageA(A,send_message(question(Tr,italian,M),translator)).
examine_translation(Q,_,M,A):-translatedP(Q,Tr),
messageA(A,send_message(question(Tr,italian,M),translator)).
examine_translation(Q,_,M,A):-clause(translated(Tr,Q),_),
messageA(A,send_message(question(Tr,english,M),translator)).
translated(i,io).
translated(love,amo).
translated(hate,odio).
translated(you,te).
Cooperation and Ontology
The environment…
ITALIAN
questionE(Term,Language,From)
ITALIAN ENGLISH
know(io,gino). know(i,susy).
know(amo,gino). know(love,susy).
know(odio,gino). know(hate,susy).
know(te,gino). know(you,susy).
TRANSLATOR
translated(i,io).
translated(love,amo).
translated(hate,odio).
translated(you,te).
ITALIAN
ITALIAN ENGLISH
know(io,_) know(i,_)
know(amo,_) know(love,_)
know(te,_) know(you,_)
evviva_loves_me(susy)
Run the DALI logic programs italian.txt

|: gino.
Insert From
|: susy.
Insert message
|: send_message(question(i,english,susy),susy). Insert name of addressee
|: gino..
Insert From
|: susy.
Insert message
|: gino.
|: send_message(question(you,english,susy),susy).
Insert From
|: susy.
Insert message
|: send_message(question(love,english,susy),susy).
italian/gino
.................. Actived Agent...............

send_message_to(translator,send_message(translate(i,english,susy,gino),gino),
italian,[])
send_message_to(susy,send_message(know(io,gino),gino),italian,[])
send_message_to(translator,send_message(translate(love,english,susy,gino),gi
no),italian,[])
send_message_to(susy,send_message(know(amo,gino),gino),italian,[])
send_message_to(translator,send_message(translate(you,english,susy,gino),gin
o),italian,[])
send_message_to(susy,send_message(know(te,gino),gino),italian,[])
make(evviva_loves_me(susy))
english/susy
.................. Actived Agent...............

make(comprehension)
make(comprehension)
make(comprehension)
translator
.................. Actived Agent ...................

send_message_to(gino,send_message(question(io,italian,susy),translator),italian,[])
send_message_to(gino,send_message(question(amo,italian,susy),translator),italian,[])
send_message_to(gino,send_message(question(te,italian,susy),translator),italian,[])
ITALIAN
ITALIAN ENGLISH
know(io,_) know(i,_)
know(odio,_) know(hate,_)
know(te,_) know(you,_)
i_will_not_speak_with(susy)
add_pastA(enemy(susy))
told(Ag,send_message(_)):-not(enemyP(Ag)).
Eliminated message know(you,_)

Insert name of addressee Insert name of addressee

|: gino. |: gino.
Insert From Insert From
|: susy. |: susy.
Insert message Insert message
|: send_message(question(i,english,susy),susy). |: send_message(question(hate,english,susy),susy).

|: gino.
Insert From
|: susy.
Insert message
|: send_message(question(you,english,susy),susy).
italian/gino
.................. Actived Agent...............
send_message_to(translator,send_message(translate(you,english,susy,gino),gin
o),italian,[])
send_message_to(susy,send_message(know(te,gino),gino),italian,[])
send_message_to(translator,send_message(translate(i,english,susy,gino),gino),
italian,[])
send_message_to(susy,send_message(know(io,gino),gino),italian,[])
send_message_to(translator,send_message(translate(hate,english,susy,gino),gi
no),italian,[])
send_message_to(susy,send_message(know(odio,gino),gino),italian,[])
make(i_will_not_speak_with(susy))
Eliminated message:conditions not verified for
send_message(question(hate,english,susy),susy)
From:susy:arianna:1075Language:italianOntology:[]
send_message_to(susy,inform(send_message(question(hate,english,susy),susy)
,motivation(refused_message),gino),italian,[])
english/susy translator
........ Actived Agent........ ............. Actived Agent ..........

make(comprehension) send_message_to(gino,send_message(
make(comprehension) question(te,italian,susy),translator),itali
make(comprehension) an,[]) …
make(comprehension)
ITALIAN
ENGLISH ITALIAN
send_message(give_present(A),A)
accept_presentA,
drop_pastA(enemy(A))
(the filter accepts the messages as give_present(_))
Susy,after the present, isn’t an enemy and the communication

is again authorized by the filter.
recovery_friendship(Ag):-informP(_,motivation(refused_message),Ag).
recovery_friendshipI(Ag):>clause(agent(A),_),
messageA(Ag,send_message(give_present(A),A)).
italian/gino
.................. Actived Agent...............

make(accept_present)
send_message_to(translator,send_message(translate(hate,english,susy,gino),gi
no),italian,[])
send_message_to(susy,send_message(know(odio,gino),gino),italian,[])
english/susy
.................. Actived Agent...............

send_message_to(gino,send_message(give_present(susy),susy),italian,[])
make(comprehension)

DALI Handbook

Uploaded by

Copyright:

Available Formats

You might also like

DALI Handbook

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

DALI Handbook

Uploaded by

Copyright:

Available Formats

DALI Multiagent System

Handbook and Examples

 How the DALI Interpreter starts

 How to create an agent:

 How to write a DALI logic program

 Architecture of the DALI Interpreter

load_files('C:/Programmi/SICStus Prolog 3.11.1/bin/demo/active_server.pl').

load_files('C:/Programmi/SICStus Prolog 3.11.1/bin/demo/active_user.pl').

The name of the Receiver agent

The language of the message

The list of terms useful to interprete

The name of the Sender agent

The content of the message

.................. Actived Agent ...................

These parameters are grouped in a string with prefix ‘agent’,

The path is specified starting from the directory where the

‘gino’ is the name of the agent,

Finally, ‘communication’ is the file ‘communication.con’ in the

The last parameter suggests that the agent is a tourist.

At this point, we can write a DALI logic program with .txt

Insert name of addressee

Insert From The name of the Sender agent

Insert message The content of the message

Insert name of addressee

The external events are syntactically indicated by the postfix E. When an

.................. Actived Agent ...................

The DALI agent will do the action contained in the body

The internal events define a kind of individuality of a DALI agent, making

.................. Actived Agent ...................

.................. Actived Agent ...................

where To is the name of the agent that must receive the

We now describe the primitives used in a DALI program.

Nome file: shoes.txt

A past event, indicated by the suffix P, is:

o an external or internal event after a reaction;

Insert name of addressee

Reaction rule dangerE:>once(ask_for_help).

[danger]. External events

[]. Goals to reach This file is used by the interpreter to

Past event External event

We can decide how long or until We can decide if an external event

We can decide if an action

mod(Action, check). action(Action,high).

we can set parameters as:

o when/until when the interpreter must attempt the internal event:

action(call_police,normal). The action is put in the queue with normal priority

past_event(danger,20). This past event is kept in memory 20 seconds

This message is submitted to tell check

The message, submitted to tell check, is

"PREFIX rdfs:<http://www.w3.org/2000/01/rdf-schema#>". ← Prefixes of namespaces

A message that does not go through the tell level is eliminated.

DALI logic program help.txt

Run the DALI logic program

Insert name of addressee

.................. Actived Agent ...................

New message If the agent has a phone…

.................. Actived Agent ...................

DALI logic program recovery.txt