Modelling the behaviour of concurrent agents that interact and reason in a dynamic environment is a dificult task. It requires tools that can efectively capture diferent types of interactions, such as persuasion and deliberation, while helping agents make decisions or reach agreements. This paper proposes a revised and extended version of the (timed) concurrent language for argumentation, better suited for modelling real-world scenarios. Our focus is on private information: we have given each agent a local argumentation store for reasoning with private knowledge. With this feature, agents can use the argumentation engine to implement courses of action based on their personal information and only disclose the bare minimum. Finally, we present an application example that models a privacy-preserving multi-agent decision-making process to demonstrate the capabilities of our language.
Intelligent agents can exploit argumentation techniques to accomplish complex interactions
like, for instance, negotiation [
This paper introduces a number of new features aimed at facilitating the use of the language and making it more suitable for modelling real-world interaction scenes. The main contributions we will discuss are as follows:
• local stores that agents can use to enhance their reasoning with private information; • the possibility of optional timeouts to make some operators more flexible; • syntactic sugar that simplifies the modelling of complex situations recurring in real cases. Autonomous agents can benefit from local stores for hiding data they are unwilling to disclose and only making public the necessary information needed to reach the desired outcome. Think, for example, about intelligent agents negotiating over a shared resource. Some information owned by the agents might have a future strategic value or be subject to privacy concerns. While this kind of information should remain unavailable to other agents, the owner must be able to integrate it into the reasoning process. Our language allows modelling agents endowed with both a shared and a local store to realise the behaviour reported above. Timeouts are another fundamental component to enable proper interaction between agents. Usually, in the real world, one has limited time to make a decision on the next action to be taken. In some situations, however, especially when working with partial knowledge, agents must be able to wait for an indefinite amount of time until a certain condition is fulfilled. We also included an application example for showing the capabilities of tcla, with particular focus on using local stores. Contextually, we present syntactic sugar for realising frequently used complex operations.
In this section, we recall some fundamental notions concerning Computational Argumentation.
The first definition we need is that of Abstract Argumentation Framework (AF) [
Given an AF, we want to identify subsets of acceptable arguments which are selected by
applying criteria called argumentation semantics. Non-accepted arguments are rejected. Diferent
kinds of semantics have been introduced that reflect desirable qualities for sets of arguments.
Among the most studied ones, we find the admissible, complete, stable, semi-stable, preferred,
and grounded semantics [
Definition 2. A labelling of an AF = ⟨, ⟩ is a total function : → {in, out, undec}. Moreover, is an admissible labelling for when ∀ ∈ • () = in =⇒ ∀ ∈ | (, ) ∈ .() = out; • () = out ⇐⇒ ∃ ∈ | (, ) ∈ ∧ () = in.
In other words, an argument is labelled in only if all its attackers are labelled out, and it is labelled out when at least one in node attacks it. In all other cases, the argument is labelled undec. In particular, in arguments are acceptable, while the others will be rejected. 1The set is not present in the original definition by Dung and we introduce it for our convenience to distinguish all possible arguments from the adopted ones.
Similar criteria to that shown in Definition 2 can be used to capture other semantics [
Communication between tcla agents is implemented via shared memory, similarly to cla [10] and CC [11], and opposed to other languages (e.g. CSP [12] and CCS [13]) based on message passing. In tcla, the shared memory consists of an AF which agents can access and modify. All agents are synchronised via a shared global clock, tracking the simultaneous execution of concurrent agents. We present the syntax of tcla in Table 1, where denotes a generic process, a sequence of procedure declarations (or clauses), a generic agent and a generic guarded agent. ::= check(, ) → | c-test(, , ) → | s-test(, , ) → | + | + where and are supposed to be sets of arguments, a set of attacks, an argument, ∈ {in, out, undec}, ∈ {adm, com, stb, prf, gde}.
In a process = , is the initial agent to be executed in the context of the set of declarations . A clause defined with , corresponds to the concatenation of more procedure declarations. An agent behaves like agent where arguments in and attacks built from are local to . Before describing in detail how the operators in Table 1 work, let us introduce the notion of timeout used by guarded agents (i.e., the check, c-test and s-test operations). Those agents verify if arguments and attacks in the shared memory meet certain properties and can be executed again in case they do not succeed. To specify how many times the execution can be repeated, guarded agents are endowed with a timeout ∈ N ∪ {∞} stating after how many cycles of the global clock the operation will expire and terminate with failure.
The passing of time between all concurrent agents is handled on the same global clock via a timeout environment as specified below. Let ℐ be a set of (timeout) identifiers. A timeout environment is a partial mapping : ℐ ⇀ N ∪ {∞} such that the set ( ) = { ∈ ℐ | () ∈ N ∪ {∞}} (domain of ) is finite. 0 is the empty timeout environment ((0) = ∅). As we need to manipulate , for instance, to insert new timeouts or update a timer, we introduce some utility functions. If 1 and 2 are timeout environments such that for each ∈ (1) ∩ (2) we have that 1() = 2(), then 1 ∪ 2 is the timeout environment such that (1 ∪ 2) = (1) ∪ (2) and for each ∈ (1 ∪ 2) We denote by [¯ : ¯] an update of , with a possibly enlarged domain, namely (1 ∪ 2)() = {︃1() 2() if ∈ (1) otherwise [¯ : ¯]() = {︃ () ¯ if ̸= ¯ otherwise The passing of time is marked by decreasing timers in a timeout environment . At each step of the execution, all timers are decreased according to the function ( ) such that (( )) = ( ) and ( )() = {︃ () − 1 () if 0 < () ∈ N if () = 0 or () = ∞
In this paper, we only consider the parallelism achieved with the true concurrency paradigm, i.e., all concurrent agents can be executed simultaneously as if an infinite number of processors were available. The adoption of a global clock defined via timeout environment allows time to elapse for all agents, not only in the case of true concurrency but also, for example, with interleaving (i.e., only one parallel agent is executed at a time) which could be introduced in future work. Below, we outline the functioning of all tcla operators, focusing in particular on the management of the timeouts and the composition of concurrent agents. Notation 1. Let = ⟨, ⟩ be an AF and a set of arguments. We define: • | = {(, ) ∈ | ∈ or ∈ }; • ‖ = {(, ) ∈ | ∈ and ∈ }; • ↓ = ⟨ ∩ ′, |⟩ where ′ = ∪ { | (, ) ∈ | or (, ) ∈ |}; • ↑ = ⟨ ∖ , ∖ |⟩.
The operational model of tcla processes can be formally described by a transition system = (Conf , →− ), where we assume that each transition step takes exactly one time-unit. Conifgurations (in) Conf are triples, each triple consisting in a process , an abstract argumentation framework representing a knowledge base and a timeout environment . The transition relation →−⊆ Conf × Conf is the least relation satisfying the rules in Tables 2 - 8, and it characterises the (temporal) evolution of the system. So, ⟨, , ⟩ →− ⟨ ′, ′, ′⟩ means that, if at time we have the process , the framework and the time environment , then at time + 1 we have the process ′, the framework ′ and the time environment ′. In the following, we will usually write a tcla process = . as the corresponding agent , omitting when not required by the context.
Rules Ad and Re of Table 2 modify the store by adding and removing, respectively, arguments and attacks. Attacks can only be added between arguments that will be in the store after the
⟨add(′, ′) → , ⟨, ⟩, ⟩ →− ⟨ , ⟨ ∪ ′, ( ∪ ′)‖(∪′)⟩, dec( )⟩ ⟨rmv(′, ′) → , ⟨, ⟩, ⟩ →− ⟨ , ⟨ ∖ ′, ( ∖ ′)‖(∖′)⟩, dec( )⟩ Ad Re execution of the add operation. On the other hand, when an argument is removed, also the attacks involving that argument are removed.
Table 3 presents the semantics for the check operation. Whenever a rule is executed, all timers in the timeout environment are decremented after the possible introduction of new timeouts. The first time a check is performed (rules Ch1 and Ch2), a new timeout must be inserted in . If the check is not successful on the first attempt, it will be repeated using the already existing timeout. In detail, rule Ch1 triggers when the guard of the agent is satisfied, and the associated timer is positive. In this case, the agent proceeds to the subsequent action. Rule Ch2 inserts a new timeout into and repeats the check operation in the next step when the condition is not satisfied and the timer has not expired. The system will use the operator ℎ (rule Ch4) to execute a check on the store with a timeout already present in . In rule Ch3, the guard succeeds, and the timer associated with the check operation is not expired and already in . Therefore, the program continues to the next action. Rule Ch4 is the counterpart of Ch2, the only diference being that no new timeout is added to . This is needed for the system to automatically repeat a check operation which did not succeed in the previous step. Note that if a timer is set to ∞ and the timeouts are decreased with dec( ), then will be left
¬(′ ⊆ ∧ ′ ⊆ ), () > 0 ⟨check (′, ′) → , , ⟩ →− ⟨ check (′, ′) → , , dec( )⟩ ⟨check0(′, ′) → , , ⟩ →− ⟨ failure, , dec( )⟩
() = 0 ⟨check (′, ′) → , , ⟩ →− ⟨ failure, , dec( )⟩ Ch1 Ch2 Ch3 Ch4 Ch5 Ch6 unchanged. This behaviour is similar to that of the check with waiting in [10]. When the timer is 0, the agent fails as per rules Ch5 and Ch6. This behaviour is similar to that of the check with failure in [10]. After the execution of rules Ch3 and Ch6, i.e. when the check operation has terminated with success or failure, respectively, the timeout that was potentially entered in becomes useless since no rule will inspect it afterwards. In this sense, a garbage collection procedure that removes from the timeouts that are no longer used could be introduced.
Credulous and sceptical test operators perform a semantic verification on the acceptability of arguments in the store. Their rules follow the same idea as those for the check operation, with the only exception of the condition to satisfy, that is, respectively ∃ ∈ ℒ | () = for c-test (, , ) and ∀ ∈ ℒ .() = for s-test (, , ) instead of ′ ⊆ ∧ ′ ⊆ . The guard for the credulous test is satisfied when there exists at least one labelling of for a chosen semantics such that () = . The sceptical test, instead, demands be assigned the label by any labelling in ℒ .
In Table 4, which concerns the rules for nondeterminism, and in Table 5 that realises the if-then-else, ℰ is the class of guarded agents, while ℰ a subset of the former class such that all outermost guards have either the associated timer () = 0 or the timer on the check/test expression set to 0 ( = 0). In other words, the execution of agents in ℰ always leads to termination with failure. Rule ND1 states that if two non-failing expressions 1 and 2 composed through the operator + can transit into guarded expressions 1′ and 2′, respectively, they will do so in the same execution step, producing the agent 1′ + 2′. According to rule ND2, the execution continues with 1 if it can transit into a non-guarded agent. Finally, if one of the two agents fails, it is discarded, and the execution continues with the other agent (rule ND3).
The operator of Table 5 realises the (non-commutative) if-then-else construct: if we have 1 + 2 and 1 can transit into 1′, like in rule If1, then the execution continues with 1′ + 2. If 1 transits into an agent diferent from a guarded expression, the rightmost expression is discarded (rule If2). This behaviour is diferent from that obtainable with the + operator for nondeterminism, which will arbitrarily execute one of the two branches, discarding the other. Finally, if 1 fails, the first branch is discarded and the rightmost agent is executed as per If3. Rules ND3 and If3, therefore, serve the same purpose and are identical, apart from the operator.
The procedure call defined in Table 6 only takes a single parameter that can be an argument, 1 ∈ ℰ , ⟨2, , ⟩ →− ⟨ 2, , ′⟩ ⟨1 + 2, , ⟩ →− ⟨ 2, , ′⟩ a label among in, out and undec, a semantics , or an instant of time . If necessary, this solution can be easily adjusted to accommodate additional parameters or consider parameterless procedures. Executing a procedure call corresponds to replacing each instance of with agent in the execution, according to what is specified in the procedure declaration within the context of .
⟨(), , ⟩ →− ⟨ [/], , dec( )⟩ with () :: and ∈ {, , , } PC
Rule TC in Table 7 models the true concurrency operator. It only succeeds if all the agents composed through ‖ succeed. In our implementation, we use * (, ′, ′′) := ( ′ ∩ ′′) ∪ (( ′ ∪ ′′) ∖ ) to handle concurrent additions and removals of arguments.2 If an argument is added and removed in the same instant (e.g., through the process add({}, {}) → ‖ rmv({}, {}) → ), we have two possible outcomes: if was not present in the knowledge base, then it will be added since ∈ (( ′ ∪ ′′) ∖ ); on the other hand, when was already in the shared memory, we have that ̸∈ (( ′ ∪ ′′) ∖ ), and is removed. In other words, we add the argument to shared memory if it is not present and remove it if it is already there. The operator * can nevertheless be customized to obtain diferent behaviour and fit specific requirements.
In Tables 4 and 7, we have omitted the symmetric rules for the choice operator + and the parallel composition ‖. Indeed, + is commutative, so 1 + 2 produces the same result as 2 + 1. The same is true for ‖. Moreover, and are the identity and the 2Union, intersection and diference between AFs are intended as the union, intersection and diference of their sets of arguments and attacks, respectively. absorbing elements, respectively, under the parallel composition ‖; that is, for each agent , we have that ‖ and ‖ are the agents and , respectively.
As specified by the rule in Table 8, the agent new in behaves like agent where arguments in ⊆ are considered local to , i.e. the information on provided by the external is hidden from (therefore we consider the agent executed in the argumentation framework ( ↑ ) ∪ ) and, conversely, the information on produced locally by is hidden from external world (therefore the returned argumentation framework is ( ′ ↑ ) ∪ ( ′′ ↓ ).
To describe locality, in Table 8, the syntax has been extended by an agent new in , where is a local of containing information on which is hidden from the external . When the computation starts, the local is empty, i.e. new in = new in ⟨∅,∅⟩. Finally, for each set of arguments , new in and new in are the agents and , respectively.
In the next section, we make use of some syntactic sugar to simplify the presentation of the results. Let = {1, . . . , } ⊆ and let 1 and 2 be guards of the form check(, ), c-test(, , ) or s-test(, , ): (1 ∧ 2) → represents (1 → ) ‖ (2 → ); (1 ∨ 2) → represents (1 → ) + (2 → ); true represents a dummy check∞({}, {}); false represents a dummy check0({}, {}); ∃ ∈ | check({}, ) → represents (check({1}, ) → )+ (check({2}, ) → ) + · · · Analogously for ∃ ∈ | -(, , ) → and
+ (check({}, ) → ).
∃ ∈ | -(, , ) → ; ∀ ∈ | check({}, ) → represents (check({1}, ) → )‖ (check({2}, ) → )‖ . . . ‖(check({}, ) → ).
Analogously for ∀ ∈ | -(, , ) → and ∀ ∈ | -(, , ) → .
tcla A possible use case for tcla can be identified in modelling Multi-Agent Decision Making with Privacy Preserved (DMPP) in which agents need to communicate with other agents to make socially optimal decisions but, at the same time, have some private information that they do not want to share. This problem can be instantiated as done in other works like [14] as a debate in a multi-agent environment where argumentation techniques are exploited for arriving at socially optimal outcomes by only revealing the necessary” and “disclosable” information. We start from (a slight modification of) the scenario proposed by [ 14], adapted from the Battle of the Sexes game in [15] and the meeting scheduling problem in [16]. In this example, we use the true concurrency operator from Table 7 to handle the parallel execution of agents. However, the illustrated methodology could be adjusted to also work with an interleaving approach. Example 1. Alice and Bob are trying to agree on an activity to do together for the day. Alice is more interested in going to the ballet (we represent this statement with A:Ballet), while Bob would rather watch a football game (B:Football). Their beliefs can be modelled as in the AFs of Figure 1.
Alice is worried that Bob’s ex-wife might attend the ballet as well (denoted by Ex?), but she does not want Bob to know about this concern. However, Alice was informed by Caroline, Bob’s ex-wife’s daughter, that she had gone hiking with her mother earlier that day (C:Hiking). Alice would also be concerned about the weather (Wea) in case they decide to go watch the game (Football). However, she found from a forecast that it will be sunny (Sun). We also know that Alice does not mind sharing her concerns about the weather.
On the other hand, Bob forgot whether Alice enjoys sport or not (LikeSport?) and would prefer Alice not to be aware of this. However, they recently attended a tennis match, which Alice enjoyed (EnjoyTennis). Bob also came across a Facebook post by Caroline, mentioning that she was attending the ballet (C:Facebook). Note that C:Facebook is in conflict with C:Hiking, but this will only emerge when Alice and Bob will share their arguments.
A Multi-Agent Decision Making with Privacy Preserved problem is formalised as follows. Definition 3. A Multi-Agent Decision Making with Privacy Preserved problem is a triple = ⟨, , ⟩, where • = {1 . . . , } is a finite set of agents; • = {1, . . . , } is a finite set of available actions for the agents; • = {⟨1 : 1, . . . , : ⟩ | {1, . . . , } ⊆ } the set of all strategic profiles, namely the set of all the possible tuples of actions (one for each agent) and • ⊆ is the set of the acceptable solutions of the problem.
Example 2. In Example 1, = 2, since there are two agents: (Alice) and (Bob), = 2 since there are two actions and (‘go to the ballet’ and ‘watch football’, respectively) and two acceptable solutions of the problem, namely = {⟨A:Ballet, B:Ballet⟩, ⟨ : , B:Football⟩}. Note that the two strategic profiles ⟨A:Ballet, B:Football⟩ and ⟨ : , B:Ballet⟩ are not acceptable solutions, because both agents want to attend these activities together (or not at all).
Diferently from [ 14], we model agents’ actions and acceptable solutions, which are common and visible to all agents, as public arguments. Each agent can decide for its own actions and not for those of the other agents. Therefore, the actions of one agent are disjoint from those of the others and are of the form : , where ∈ . We define the attacks between agents’ actions and acceptable solutions as follows: = {( : , ⟨1 : 1, . . . , : ⟩ | ∈ {1, . . . , }, ∈ , ⟨1 : 1, . . . , : ⟩ ∈ , and ̸= } Example 3. In Example 1 we have that = { (A:Ballet, ⟨ : , B:Football⟩), ( : , ⟨A:Ballet, B:Ballet⟩, (B:Ballet, ⟨ : , B:Football⟩), (B:Football, ⟨A:Ballet, B:Ballet⟩)) }.
Note that in this formalisation the arguments and are private arguments for Alice who uses them to privately decide what action to take, while A:Ballet and A:Football are public arguments with which Alice informs Bob of the action she would like to take. Analogously for Bob.
Now, let us consider a communication protocol inspired by Chronological synchronous backtracking (SBT), one of the simplest while most fundamental algorithms for distributed constraint satisfaction problems, which requires a static ordering of agents. Following this, agents try to make a social decision. Agents pass a token among them; the agent who has the token can check if the current solution (proposed by the first agent) is acceptable to him. In this case, send the token to the next agent; otherwise, send a message ngd (short for “not good”) to the previous agent. The communication terminates either because all the agents agree on a solution or because every solution proposed by the first agent has been discarded. In the former case, the partial solution constitutes a solution for the problem, while in the latter case, the problem is unsatisfiable. SBT is guaranteed to terminate and is sound and complete (i.e., it terminates only with correct answers and for all problems).
We can write a tcla program emulating a multi-agent decision making with privacy preserved to model the Battle of Sexes game. We know that Alice’s preference is the sequence of actions Ballet · Football, while Bob’s preference is the sequence of actions Football · Ballet. Moreover, Alice and Bob’s private information is represented by the following two AFs, respectively: =⟨ {Ballet, Football, Ex?, C:Hiking, Wea},
{(Ex?, Ballet), (Wea, Football), (C:Hiking, Ex?)}, and =⟨ {Ballet, Football, LikeSport?, EnjoyTennis},
{(EnjoyTennis, LikeSport?), (LikeSport?, Football)}.
The interaction that takes place between Alice and Bob in order to reach a jointly agreed decision can be modelled in tcla as reported in Tables 9 and 10, respectively. The computation of () ‖ () starts in an initial public shared framework
Suppose Alice is ranked higher in the static agent ordering; thus, she obtains the token first. Since a final agreement has to be reached, the order of the participants does not influence the final result in this example. Diferent outcomes may, however, be ob+ → rmv({A:Ballet}, ∅) → (Football) ) + → (Football) and (Football) = -1(Football, in, ) → ( add({A:Football}, {(A:Football, ⟨A:Ballet, B:Ballet⟩)}) → ( ( -1(⟨A:Ballet, B:Ballet⟩, in, ) ∨ -1(⟨A:Football, B:Football⟩, in, ) ) → ( add({}, ∅) → ( check∞({}, ∅) → + check∞({}, ∅) → rmv({, A:Football}, ∅) →
) ) ) + → rmv({A:Football}, ∅) → ) + → + → rmv({B:Football}, ∅) → (Ballet) ) + → rmv({B:Ballet}, ∅) → add({}, ∅) → ) + → add({}, ∅) → tained depending on the preference for the actions taken by the agents in their turns. Alice checks whether her most preferred action Ballet (“going to the ballet”) is globally feasible (-1(Ballet, in, )) in the framework ∪ , but she gets a negative answer; Alice thus checks her next preferred action, i.e. watching football (Football), and she finds that it is feasible. So she adds {A:Football}, {(A:Football, ⟨A:Ballet, B:Ballet⟩)} (Alice, “watch football”) in and then checks the consistency of A:Football with respect to the current partial solution (which is empty) and the acceptable solutions, namely she runs -1(⟨A:Ballet, B:Ballet⟩, in, ) ∨ -1(⟨A:Football, B:Football⟩, in, ). In this case, there exists an acceptable solution ⟨A:Football, B:Football⟩ in the global framework which is admissible. Thus Alice adds (for Bob) to the global framework, obtaining a new global framework ′ = ⟨{C:Hiking, Wea, Sun, EnjoyTennis, C:Facebook, A:Football, , ⟨A:Ballet, B:Ballet⟩, ⟨A:Football, B:Football⟩}, {(Sun, Wea), (C:Facebook, C:Hiking), (A:Football, ⟨A:Ballet, B:Ballet⟩}⟩.
Once Bob has verified the presence of the token in the global framework, he starts proposing his own actions. He begins with his favourite action Football (“watching football”), and he finds that it is feasible by using -1(Football, in, ) in ∪ ′. So he adds {B:Football}, {(A:Football, ⟨A:Ballet, B:Ballet⟩)} (Bob, “watch football”) to ′. Then he analyses the consistency of B:Football with respect to the current partial solution (which now includes Alice’s proposal A:Football) and the acceptable solutions. Analogously to Alice, he executes -1(⟨A:Ballet, B:Ballet⟩, in, ) ∨ -1(⟨A:Football, B:Football⟩, in, ). Again, we can find an acceptable solution ⟨A:Football, B:Football⟩ in the global framework which is admissible. Since Bob is the last agent, he adds to the global framework and terminates with success. Finally, Alice verifies the presence of the token in the global framework and terminates with success as well. In the global framework, we find the solution to the problem, which is the only admissible acceptable solution ⟨A:Football, B:Football⟩.
Note that we can construct another model where Alice and Bob always have a private knowledge base, but the two agents simply work concurrently. However, the illustrated methodology could be easily adjusted to also model generic Multi-Agent Decision Making with Privacy Preserved, with any number of agents.
We have introduced a new version of tcla with local stores to allow agents to keep important data private while still incorporating it into their decision-making processes. As a result, our language is well-suited to model real-life scenarios, and we have provided an example of how it can be used in a privacy-preserving setting to make decisions.
In the future, we plan to further extend tcla to capture more aspects that may influence the behaviour of agents interacting through the exchange of arguments. For instance, we want to endow the agents with a notion of ownership to establish which actions can be performed on the shared arguments. In the current implementation, an autonomous agent could remove arguments added to the shared store by its opponents in order to win a debate. However, this is not an efective solution in practical cases and is also considered an illegal move in dialogue games. In addition, since the reasoning process of an agent involved in some form of interaction (e.g. persuasion) usually includes elaborating a winning strategy, we want to introduce tcla constructs that a user can employ to identify the best sequence of actions to perform. To this end, we could resort either to a greedy approach, in which the agent identifies the best actions with respect to a given time instant (and configuration of the shared store), or to a more robust, optimised strategy that spans over a certain number of execution steps. Together with true concurrency, we also want to include an interleaving operator for handling parallel agents. The user may rely on both constructs depending on the purpose. Finally, we plan to use the language to model chatbot interactions [17] and explanation activities [18].
The authors are members of the INdAM Research group GNCS and of the Consorzio CINI. This work has been partially supported by: Project “Empowering Public Interest Communication with Argumentation (EPICA)”, (MIUR PRIN); INdAM - GNCS Project, CUP E53C22001930001; Projects BLOCKCHAIN4FOODCHAIN, FICO, AIDMIX, “Civil Safety and Security for Society” (“Fondo Ricerca di Ateneo”, University of Perugia; years 2020, 2021, 2022); Project GIUSTIZIA AGILE, CUP J89J22000900005; Project VITALITY, CUP J97G22000170005 (NRRP-MUR). [10] S. Bistarelli, C. Taticchi, A concurrent language for modelling agents arguing on a shared argumentation space, Argument & Computation Pre-press (2023) 1–28. doi:10.3233/ AAC-210027. [11] V. A. Saraswat, M. Rinard, Concurrent constraint programming, in: Proc. of POPL 1990 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, ACM Press, 1990, pp. 232–245. doi:10.1145/96709.96733. [12] C. A. R. Hoare, Communicating sequential processes, Commun. ACM 21 (1978) 666–677.
URL: https://doi.org/10.1145/359576.359585. [13] R. Milner, A Calculus of Communicating Systems, volume 92 of LNCS, Springer, 1980. URL: https://doi.org/10.1007/3-540-10235-3. [14] Y. Gao, F. Toni, H. Wang, F. Xu, Argumentation-based multi-agent decision making with privacy preserved, in: Proceedings of the 2016 International Conference on Autonomous Agents & Multiagent Systems, Singapore, May 9-13, 2016, ACM, 2016, pp. 1153–1161. [15] I. Rahwan, K. Larson, Argumentation and game theory, in: Argumentation in Artificial
Intelligence, Springer, 2009, pp. 321–339. [16] M. Silaghi, D. Mitra, Distributed constraint satisfaction and optimization with privacy enforcement, in: 2004 IEEE/WIC/ACM International Conference on Intelligent Agent Technology (IAT 2004), 20-24 September 2004, Beijing, China, IEEE Computer Society, 2004, pp. 531–535. [17] S. Bistarelli, C. Taticchi, F. Santini, A chatbot extended with argumentation, in: M. D’Agostino, F. A. D’Asaro, C. Larese (Eds.), Proceedings of the 5th Workshop on Advances in Argumentation in Artificial Intelligence 2021 co-located with the 20th International Conference of the Italian Association for Artificial Intelligence (AIxIA 2021), Milan, Italy, November 29th, 2021, volume 3086 of CEUR Workshop Proceedings, CEUR-WS.org, 2021. URL: https://ceur-ws.org/Vol-3086/short2.pdf. [18] S. Bistarelli, A. Mancinelli, F. Santini, C. Taticchi, Arg-xai: a tool for explaining machine learning results, in: M. Z. Reformat, D. Zhang, N. G. Bourbakis (Eds.), 34th IEEE International Conference on Tools with Artificial Intelligence, ICTAI 2022, Macao, China, October 31 - November 2, 2022, IEEE, 2022, pp. 205–212. URL: https://doi.org/10.1109/ICTAI56018. 2022.00037. doi:10.1109/ICTAI56018.2022.00037.