Transcript DALI Multiagent System
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_server.pl/ active_server.exe
active_dali.pl/ active_dali.exe
. . .
active_user.pl/ active_user.exe
active_dali.pl/ active_dali.exe
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
bin demo active_server.pl/ active_server.exe
active_user.pl
active_server.pl
program file_dali.txt
active_dali.pl
We can activate the DALI server either by invoking the the executable file ‘active_server.exe’ 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 ‘active_user.exe’ 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
How the DALI Interpreter starts
active_dali.pl/ active_dali.exe
We can activate the DALI Interpreter either by using the executable file ‘acive_dali.exe’ or, via the Sicstus Prolog shell, by loading the file ‘active_dali.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_dali.pl').
The interpreter will ask the name of the initialization file: Insert the path and the name of the initialization file: |: 'demo/help.txt'.
And, after this information, the agent will be activated: .................. Actived Agent ...................
Initialization file
help.txt
bin demo active_user.pl
program active_server.pl
DALI logic program
help.txt
In this way it is possible to activate several DALI agents having different names and logic programs.
active_dali.pl
DALI initialization file
The initialization file
The name of the file that contains the DALI logic program; The name of the agent; The adopted ontology (a txt file); 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, 'demo/pippo_ontology.txt',italian, ['demo/communication'], ['demo/communication_fipa'],[tourist]).
The path is specified starting either from the directory bin if we use the Sicstus Prolog shell or starting from the directory where the interpreter is if we use the DALI executable file.
DALI initialization file: example
Precisely: ‘gino’ is the name of the agent, ‘ontology.txt’ is the ontology file in the directory ‘demo’ and Italian is the language spoken by the agent.
Finally, ‘communication’ is the file ‘communication.con’ in the directory ‘demo’ containing the tell/told constraints and ‘communication_fipa’ is the library with the fipa communication’s primitives.
The last papameter 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
bin In the initialization string (see above) we put the initialization file under the directory demo and the DALI logic program file ‘file_dali.txt’ in the directory program: communication.con
communication_fipa.txt
demo ontology.txt
program file_dali.txt
active_dali.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 |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: send_message(danger,user).
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
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:
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) .
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [danger].
Insert From |: user.
% this is to be replaced in place of the following event 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 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: E . When an 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
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: send_message(alarm_clock_rings,user).
Nome file: alarm.txt
.................. 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 so that the reaction (in the second rule) may happen.
If we write in the txt file those two rules: I , and its description is composed of two rules. The first one contains the conditions (knowledge, past events, procedures, etc.) that must be true i_am_lazy:-alarm_clock_rings P not(stand_up P ) i_am_lazy I :> i_take_a_vacation_day A .
the agent exhibits the following behavior. We use the user module to send to the agent the past event paragraph, and arrived before.
alarm_clock_rings P but this past event could be the past form of the external event as specified in the previous
Write DALI logic program:External Event
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(alarm_clock_rings,user).
Nome file: alarm_clock.txt
.................. 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 she makes the actions the action get_dressed and open_the_door event has been processed before the external event. Else, she does only 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 erases the reaction to the internal event.
bell_rings to the agent, if the internal open_the_door ,
Write DALI logic program:Present Events
Insert name of addressee |: Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: pippo.
send_message(bell_rings,user).
Nome file: wear.txt
.................. 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.
Write DALI logic program:Actions
We now describe the primitives used in a DALI program.
Sender is the agent that sends the message.
o o o o
send_message(External_event, Sender) this primitive is used to call an external event within a reactive rule; confirm(Assertion, Sender) this primitive is used to assert a fact within a DALI agent; disconfirm(Assertion, Sender) this primitive is used to retract a fact within a DALI agent; 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.
Write DALI logic program:Actions
o o o o
execute_proc(Head, Sender) this primitive is used to invoke the head of a generic rule (procedure) in the DALI program; 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; agree(Fact, Sender) this primitive is used to answer an agent knowing a ground Fact; 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.
Goal
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
PLANNER
Actions Plan to reach a goal ..., goal1G ,...
goal1 : condition 11 ,...,condition 1k subgoal 11 G,...,subgoal 1N G, subgoalP 11 ,...,subgoalP 1N .
...
goal1 : condition m1 ,...,condition mk subgoalG m1 ,...,subgoalG mN , subgoalP 11 ,...,subgoalP 1N .
goal1I :>action 1 ,..., goal2G ,...,action k .
Write DALI logic program: Goals
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.
Write DALI logic program: Goals
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(have_left_sock,user).
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(have_right_sock,user).
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: 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.
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(rain,user).
past(rain,timestamp, user) is recorded within DALI shell.
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.txt
file.ple
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 Action rule dangerE:>once(ask_for_help).
ask_for_help:-call_policeA.
call_police:
ask_for_help:-screamA.
Past event 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 Goals to test This file is used by the interpreter to manage the behavior of the agent through the classes of the events, 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))).
Dali txt program predator_attacksE(X):> once(try_to_escape(X)).
try_to_escape(X):-flyA(X).
try_to_escape(X):-runA(X).
fly(X):
The interpreter generates a pl file where all rules are subjected to ‘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 We can decide how long or until which condition a past event must be kept in the memory of an agent:
past_event(Event,Seconds). (the past event is kept in memory some Seconds) 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)
External event We can decide if an external event must be processed with a normal or high priority:
external_event(Event,normal).
external_event(Event,high).
Action/Message We can decide if to submit a message to tell the tell check:
mod(Action, check).
Action We can decide if an action must be processed with a normal or high priority:
action(Action,normal).
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 o
until_cond(Condition) forever : forever : when the Condition is false;
Some directives of plf example file
action(call_police,normal).
action(scream,normal).
action(go_to_bathroom,normal).
action(close_the_door,normal).
The action is put in the queue with normal priority
action(go_to_neighbour,normal).
external_event(danger,normal).
past_event(danger,20).
past_event(remain_at_home,20).
past_event(go_out,20).
past_event(call_police,20).
past_event(scream,20).
past_event(go_to_bathroom,20).
past_event(close_the_door,20).
past_event(go_to_neighbour,20).
This past event is kept in memory 20 seconds This internal event is attempted every 3 seconds The agent will react forever We specify no conditions 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 META LEVEL
If the agent doesn’t know the content of the message, she calls the meta-level and uses the ontology and/or other properties in order to understand the communication act.
DALI INTERNAL INTERPRETER
TELL CHECK
Outcoming message The message, submitted to tell check, is sent only if the corresponding tell rule is true.
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 ,…,constraint n .
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 txt file that the agent must use. This file contains some strings with the following prefix and parameters: ontology(Agent_name, Term1,Term2).
where Agent_name is the name of the agent that can use the association of terms Term1 and Term2. In this file the user can write some properties of terms useful to meta-procedure. For example: symmetric(love(julie,tom)).
specifies that the term love is symmetric.
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 ,…,constraint n .
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!
Examples – A dangerous situation…
Initialization file name: help.txt
DALI logic file name: help.txt
bin demo help.txt
active_user.pl
active_server.pl
program help.txt
active_dali.pl
Examples – A dangerous situation…
DALI logic program help.txt
dangerE:>once(ask_for_help).
ask_for_help:-call_policeA.
call_police:
ask_for_help:-screamA.
remain_at_home:-dangerP,call_policeP.
remain_at_homeI:>go_to_bathroomA, close_the_doorA.
go_out:-dangerP,screamP.
go_outI:>go_to_neighbourA.
Examples – A dangerous situation…
Run the DALI logic program Inserire il percorso ed il nome del file di inizializzazione: |: 'demo/help.txt'.
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: send_message(danger,user).
.................. Actived Agent ...................
make(scream) make(go_to_neighbour)
Examples – A dangerous situation…
If the agent has a phone… New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: user. Insert message |: confirm(have_a_phone,user).
New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: user. Insert message |: send_message(danger,user). she reacts differently!
.................. Actived Agent ...................
make(call_police) make(go_to_bathroom) make(close_the_door)
Examples – Error Recovery planning…
Two Agents!
Examples – Error Recovery planning…
Initialization file name: recovery.txt and sensor.txt
DALI logic file name: recovery.txt and sensor.txt
bin demo sensor.txt
recovery.txt
active_user.pl
active_server.pl
sensor.txt
program recovery.txt
active_dali.pl
Examples – Error Recovery planning…
DALI logic program recovery.txt
error_recovery(M,M1): go_rightP(_,M),goal(M),informP(reality(M,M1),sensor),M\=M1.
error_recovery(M,M1): go_leftP(_,M),goal(M),informP(reality(M,M1),sensor),M\=M1.
error_recovery(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).
Examples – Error Recovery planning…
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)):
examine_position(M,Ag,_):-right_positionA(M,Ag).
Error Recovery planning
The environment… Hospital Bank 2 Bank 1 Exit 2 Exit 1 STATION
Error Recovery planning
First situation: the agent exits from Exit 1 and goes to Hospital 1 Hospital Bank 2 Bank 1 Exit 2 STATION Exit 1 make(go_right(exit1,bank1)) make(go_left(bank1,hospital1)) confirm(i_am_at_exit(exit1),user)
Examples – Error Recovery planning…
Run the DALI logic programs recovery.txt and sensor.txt
Insert the path and the name of the initialization file: |: 'demo/recovery.txt'.
Insert the path and the name of the initialization file: |: 'demo/sensor.txt'.
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(i_am_at_exit(exit1),user).
sensor .................. Actived Agent ...................
make(right_position(hospital1,pippo)) .................. Actived Agent ...................
robot pippo make(go_right(exit1,bank1)) make(go_left(bank1,hospital1)) send_message_to(sensor,send_message(what_about_my_position(hospital1,pippo), pippo),italian,[])
Error Recovery planning
Second situation: the agent exits from Exit 2 and goes to Hospital 1 Bank 2 Bank 1 Hospital Exit 2 STATION Exit 1 make(go_right(exit2,bank2)) make(go_forward(bank2,bank1)) make(go_left(bank1,hospital1)) confirm(i_am_at_exit(exit2),user)
Examples – Error Recovery planning…
Run the DALI logic programs recovery.txt and sensor.txt
Insert the path and the name of the initialization file: |: 'demo/recovery.txt'.
Insert the path and the name of the initialization file: |: 'demo/sensor.txt'.
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(i_am_at_exit(exit2),user).
sensor .................. Actived Agent ...................
make(right_position(hospital1,pippo)) robot pippo .................. Actived Agent ...................
make(go_right(exit2,bank2)) make(go_forward(bank2,bank1)) make(go_left(bank1,hospital1)) send_message_to(sensor,send_message(what_about_my_position(hospital1,pippo), pippo),italian,[])
Error Recovery planning
Hospital 1 Bank 2 Hospital 1
?
Bank 1 Exit 2 Third situation: the agent thinks to be at Exit 1 while really she is at Exit 2 . When she is at Hospital 1 /Bank 2 a planner recognizes the error and modifies the plan.
STATION Exit 1 make(go_right(exit1,bank1)) make(go_left(bank1,hospital1)) make(recovery_error(hospital1,bank2)) make(go_forward(bank2,bank1)) make(go_left(bank1,hospital1))
Examples – Error Recovery planning… (step1)
Run the DALI logic programs recovery.txt and sensor.txt
Insert the path and the name of the initialization file: |: 'demo/sensor.txt'.
Insert name of addressee |: sensor.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(error(hospital1,bank2),user).
sensor .................. Actived Agent ...................
Examples – Error Recovery planning… (step2)
Run the DALI logic programs recovery.txt and sensor.txt
Insert the path and the name of the initialization file: |: 'demo/recovery.txt'.
Insert name of addressee |: sensor.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(i_am_at_exit(exit1),user).
.................. Actived Agent...............
bank2),sensor),italian,[]) make(wrong_position(hospital1,pippo)) sensor send_message_to(pippo,inform(reality(hospital1, .................. Actived Agent ...................
make(go_right(exit1,bank1)) make(go_left(bank1,hospital1)) robot pippo send_message_to(sensor,send_message(what_about_my_position(hospital1,pippo),pippo), italian,[]) make(recovery_error(hospital1,bank2)) make(go_forward(bank2,bank1)) make(go_left(bank1,hospital1))
Examples – Informations and Meta-reasoning…
Two Agents!
Examples – Informations and Meta-reasoning…
Initialization file name: agent1.txt and agent2.txt
DALI logic file name: agent1.txt and agent2.txt
bin demo agent1.txt
agent2.txt
active_user.pl
active_server.pl
agent1.txt
program agent2.txt
active_dali.pl
Examples – Informations and Meta-reasoning…
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.
Examples – Informations and Meta-reasoning…
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
Insert the path and the name of the initialization file: |: 'demo/agent1.txt'.
Insert name of addressee |: pippo.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: user.
Insert message |: confirm(ama(james,julia),user).
Examples – Informations and Meta-reasoning…
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 Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |: query_ref(ama(julia,Y),1,pino).
pippo),italian,[]) .................. Actived Agent ...................
send_message_to(pino,inform(query_ref(ama(julia,fdvar_9),1),values([ama(james,julia)]), (fdvar is the reification method of the Sicstus Prolog)
Examples – Informations and Meta-reasoning…
New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |: query_ref(love(julia,Y),1,pino).
pippo),italian,[]) .................. Actived Agent ...................
send_message_to(pino,inform(query_ref(love(julia,fdvar_10),1),values([ama(james,julia)]),
Examples – Informations and Meta-reasoning…
New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. 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!
Examples – Cooperation and Ontology…
Initialization file name: italian.txt, english.txt and translator.txt
DALI logic file name: italian.txt, english.txt and translator.txt
italian.txt
english.txt
bin translator.txt
demo progra m active_dali.pl
active_server.pl
active_user.pl
translator.txt
english.txt
italian.txt
Examples – Cooperation and Ontology…
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)):
examine_question(Q,L,M,A): messageA(translator,send_message(translate(Q,L,M,A),A)).
message(translator,send_message(translate(_,L,_,_),_)):< L=english.
examine_question(Q,L,M,A): messageA(M,send_message(not_know(Q,L,A),A)).
message(_,send_message(not_know(_,L,_),_)):< L=italian.
… know(io,gino).
know(amo,gino).
know(odio,gino).
ITAL IAN
Examples – Cooperation and Ontology…
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)):
examine_question(Q,L,M,A): messageA(translator,send_message(translate(Q,L,M,A),A)).
message(translator,send_message(translate(_,L,_,_),_)):< L=english.
… ITAL IAN know(io,gino).
know(amo,gino).
know(odio,gino).
Examples – Cooperation and Ontology…
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)):
examine_question(Q,L,M,A): messageA(translator,send_message(translate(Q,L,M,A),A)).
message(translator,send_message(translate(_,L,_,_),_)):< L=italian.
… know(i,susy).
know(love,susy).
know(hate,susy).
know(you,susy).
Examples – Cooperation and Ontology…
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… ITAL IAN questionE(Term,Language,From) ITALIAN know(io,gino).
know(amo,gino).
know(odio,gino).
know(te,gino).
ENGLISH know(i,susy).
know(love,susy).
know(hate,susy).
know(you,susy).
TRANSLATOR translated(i,io).
translated(love,amo).
translated(hate,odio).
translated(you,te).
ITAL IAN ITALIAN know(io,_) know(amo,_) know(te,_)
Cooperation and Ontology
ENGLISH know(i,_) know(love,_) know(you,_) evviva_loves_me(susy)
Examples – Cooperation and Ontology…
Run the DALI logic programs italian.txt
Insert the path and the name of the initialization file: |: 'demo/italian.txt'.
Insert the path and the name of the initialization file: |: 'demo/english.txt'.
Insert the path and the name of the initialization file: |: 'demo/translator.txt'.
Insert name of addressee |: gino.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: susy.
Insert message |: send_message(question(love,english,susy),susy).
Insert name of addressee |: gino.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: susy.
Insert message |: send_message(question(i,english,susy),susy).
Insert name of addressee |: gino.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: susy.
Insert message |: send_message(question(you,english,susy),susy).
Examples – Cooperation and Ontology…
italian/gino italian,[]) no),italian,[]) o),italian,[]) .................. Actived Agent...............
send_message_to(translator,send_message(translate(i,english,susy,gino),gino), send_message_to(susy,send_message(know(io,gino),gino),italian,[]) send_message_to(translator,send_message(translate(love,english,susy,gino),gi send_message_to(susy,send_message(know(amo,gino),gino),italian,[]) send_message_to(translator,send_message(translate(you,english,susy,gino),gin send_message_to(susy,send_message(know(te,gino),gino),italian,[]) make(evviva_loves_me(susy)) english/susy make(comprehension) make(comprehension) make(comprehension) .................. Actived Agent...............
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,[])
Cooperation and Ontology
ITAL IAN ITALIAN know(io,_) know(odio,_) know(te,_) ENGLISH know(i,_) know(hate,_) know(you,_) i_will_not_speak_with(susy) add_pastA(enemy(susy)) told(Ag,send_message(_)):-not(enemyP(Ag)).
Eliminated message know(you,_)
Examples – Cooperation and Ontology…
Insert name of addressee |: gino.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: susy.
Insert message |: send_message(question(i,english,susy),susy).
Insert name of addressee |: gino.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: susy.
Insert message |: send_message(question(hate,english,susy),susy).
Insert name of addressee |: gino.
Insert Language |: italian.
Insert Ontology |: [].
Insert From |: susy.
Insert message |: send_message(question(you,english,susy),susy).
Examples – Cooperation and Ontology…
italian/gino o),italian,[]) italian,[]) no),italian,[]) .................. Actived Agent...............
send_message_to(translator,send_message(translate(you,english,susy,gino),gin send_message_to(susy,send_message(know(te,gino),gino),italian,[]) send_message_to(translator,send_message(translate(i,english,susy,gino),gino), send_message_to(susy,send_message(know(io,gino),gino),italian,[]) send_message_to(translator,send_message(translate(hate,english,susy,gino),gi 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 ........ Actived Agent........
make(comprehension) make(comprehension) make(comprehension) make(comprehension) translator ............. Actived Agent ..........
send_message_to(gino,send_message( question(te,italian,susy),translator),itali an,[]) …
ENGLISH
Cooperation and Ontology
ITAL IAN 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.
Examples – Cooperation and Ontology…
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)