=Paper=
{{Paper
|id=Vol-3002/paper11
|storemode=property
|title=Timed Concurrent Language for Argumentation
|pdfUrl=https://ceur-ws.org/Vol-3002/paper11.pdf
|volume=Vol-3002
|authors=Stefano Bistarelli,Maria Chiara Meo,Carlo Taticchi
|dblpUrl=https://dblp.org/rec/conf/cilc/BistarelliMT21
}}
==Timed Concurrent Language for Argumentation==
https://ceur-ws.org/Vol-3002/paper11.pdf
Timed Concurrent Language for Argumentation?
Stefano Bistarelli1 , Maria Chiara Meo2 , and Carlo Taticchi1
1
Università degli Studi di Perugia, Italy
[stefano.bistarelli,carlo.taticchi]@unipg.it
2
Università degli Studi G. d’Annunzio di Chieti-Pescara, Italy
mariachiara.meo@unich.it
Abstract. Argumentation Theory offers formalisms for the study of rea-
soning processes taking place between intelligent entities. In this context,
time is a crucial factor: in a real-world environment, activities have a de-
termined temporal duration and the behaviour of agents is influenced
by the actions previously taken. While agent-based modelling languages
naturally implement concurrency and time constraints, the currently
available languages for argumentation do not allow to explicitly model
this type of behaviours. In this paper, we propose a language for mod-
elling concurrent interaction between agents that also allows the speci-
fication of temporal intervals in which particular actions occur. Such a
language, that we call Timed Concurrent Language for Argumentation,
allows agents to communicate with each other and to reason on the ac-
ceptability of their beliefs with respect to a given time interval. We also
show how Timed Abstract Argumentation Frameworks can be modelled
by combining time and concurrency.
Keywords: Argumentation Theory · Timed concurrent language · Se-
mantics.
1 Introduction
Argumentation Theory pursues the objective of studying how conclusions can
be reached, starting from a set of assumptions, through a process of logical rea-
soning. This process is very similar to the human way of thinking and involves
features which can be traced to a form of dialogue between two (or more) peo-
ple. Abstract Argumentation Frameworks [16], AFs in short, are used to study
the acceptability of arguments according to given selection criteria. Formalisms
like Timed Abstract Argumentation Frameworks (TAFs) [10,14,15] have been
proposed to meet the need for including the notion of time into argumentation
processes. Time is a particularly important aspect of cooperative environments:
in many “real-life” applications, the activities have a temporal duration (that
can be even interrupted) and the coordination of such activities has to take
into consideration this timeliness property. The interacting actors are mutually
?
Copyright c 2021 for this paper by its authors. Use permitted under Creative Com-
mons License Attribution 4.0 International (CC BY 4.0).
influenced by their actions, meaning that agent A reacts accordingly to the tim-
ing and quantitative aspects related to the behaviour of agent B, and vice versa.
Moreover, the information brought forward by debating agents that interact in a
dynamic environment can be affected by time constraints, limiting, for instance,
the influence of some arguments in the system to a certain time lapse. A mech-
anism for handling time is therefore required to better model the behaviour of
intelligent agents involved in argumentation processes.
With this paper, we introduce the Timed Concurrent language for Argumen-
tation (tcla), a timed extension of cla [5,6], which models dynamic interactions
between agents and uses notions from Argumentation Theory to reason about
shared knowledge. We provide both the syntax and the operational semantics.
Coordinating agents that need to take decisions both on arguments and attacks
and time events may benefit from this language. Such agents can be used, for in-
stance, to implement TAFs, namely extended AFs in which arguments are only
available for a given temporal interval. The language we present is well suited
for this kind of tasks, as Section 4 shows with examples. More complex dynamics
could also be considered: for example, an argument could be made available only
if specific conditions are met, and agents could be given priorities in introducing
arguments for certain time intervals.
tcla is based on the hypothesis of bounded asynchrony [25]: any computa-
tion takes a bounded period of time rather than being instantaneous as in the
concurrent synchronous languages esterel [3], lustre [17], signal [20] and
Statecharts [18]. Time itself is measured by a discrete global clock, i.e., the
internal clock of the tcla process. In tcla, we directly introduce a timed interpre-
tation of the programming constructs by identifying a time-unit with the time
needed for the execution of a basic action (that can be an addition, a removal
or a check of arguments/attacks, or a semantical test of arguments), and by
interpreting action prefixing (→) as the next-time operator. An explicit timing
primitive is also introduced in order to allow for the specification of timeouts.
Note that we consider a paradigm where parallel operations are expressed in
term of maximal parallelism. According to the maximal parallelism policy, at
each moment, every enabled agent of the system is activated, while in the inter-
leaving paradigm only one of the enabled agents is executed instead. By using
maximal parallelism, time passes for all the parallel processes involved in a com-
putation. This approach, analogous to the one adopted in [8,4,25], is different
from the one of [9], where time elapsing is interpreted in terms of interleaving,
although assuming maximal parallelism for actions depending on time. Our pro-
posal is also different from the one in [11], where time does not elapse for timeout
constructs.
The rest of the paper is organised as follows: in Section 2 we summarise the
most important background notions and frameworks from which tcla derives. In
Section 3 we present tcla and the operational semantics of its agents. Section 4
exemplifies the use of timed paradigms in tcla and shows an application example
of how a TAF can be dynamically instantiated, highlighting the relation between
tcla and TAFs. Section 5 describes some related work, and Section 6 concludes
the paper by also indicating future research lines.
2 Background
Argumentation Theory aims to understand and model the human natural fashion
of reasoning, allowing one to deal with uncertainty in non-monotonic (defeasible)
reasoning. In his seminal paper [16], Dung defines the building blocks of abstract
argumentation.
Definition 1 (AFs). Let U be the set of all available arguments3 , which we
refer to as the “universe”. An Abstract Argumentation Framework is a pair
hArg, Ri where Arg ⊆ U is a set of adopted arguments and R is a binary relation
on Arg.
For two arguments a, b ∈ Arg, the notation (a, b) ∈ R represents an attack
directed from a against b. We define the sets of arguments that attack (and that
are attacked by) another argument as follows.
Definition 2 (Attacks). Let F = hArg, Ri be an AF, a ∈ Arg and S ⊆ Arg.
We define +
S the+ sets aF− = {b
S ∈ Arg | (a, b) ∈ R}, a−
F = {b ∈ Arg | (b, a) ∈ R},
+ −
SF = a∈S aF and SF = a∈S aF (we will omit the subscript F when it is clear
from the context).
Definition 3 (Acceptable Argument). Given an AF F = hArg, Ri, an ar-
gument a ∈ Arg is acceptable with respect to D ⊆ Arg if and only if ∀b ∈ Arg
such that (b, a) ∈ R, ∃c ∈ D such that (c, b) ∈ R, and we say that a is defended
from D.
By using the notion of defence as a criterion for distinguishing acceptable
sets of arguments (extensions) in the framework, one can further refine the set
of selected “good” arguments. The goal is to establish which are the accept-
able arguments according to a certain semantics, namely a selection criterion.
Non-accepted arguments are rejected. Different kinds of semantics have been
introduced [16,1] that reflect qualities which are likely to be desirable. We first
recall definitions for the extension-based semantics [16], namely admissible, com-
plete, stable, semi-stable, preferred, and grounded semantics (denoted with adm,
com, stb, sst, prf and gde, respectively, and generically with σ).
Definition 4 (Extension-based semantics). Let F = hArg, Ri be an AF.
A set E ⊆ Arg is conflict-free in F , denoted E ∈ Scf (F ), when there are no
a, b ∈ E such that (a, b) ∈ R. For E ∈ Scf (F ) we have that:
– E ∈ Sadm (F ) when each a ∈ E is defended by E 4 ;
3
The set U is not present in the original definition by Dung and we introduce it for
our convenience.
4
If E ∈ Sadm (F ) we say that E is an admissible extension of F . Analogously for the
other semantics.
– E ∈ Scom (F ) when E ∈ Sadm (F ) and ∀a ∈ Arg defended by E, a ∈ E;
– E ∈ Sstb (F ) when ∀a ∈ Arg \ E, ∃b ∈ E such that (b, a) ∈ R;
– E ∈ Ssst (F ) when E ∈ Scom (F ) and E ∪ E + is maximal;
– E ∈ Sprf (F ) when E ∈ Sadm (F ) and E is maximal;
– E ∈ Sgde (F ) when E ∈ Scom (F ) and E is minimal.
Besides enumerating the extensions for a certain semantics σ, one of the most
common tasks performed on AFs is to decide whether an argument a is accepted
in some extension of Sσ (F ) or in all extensions of Sσ (F ). In the former case, we
say that a is credulously accepted with respect to σ; in the latter, a is instead
sceptically accepted with respect to σ.
Example 1. In Figure 1 we provide an example of AF where sets of extensions are
given for all the mentioned semantics: Scf (F ) = {{}, {a}, {b}, {c}, {d}, {a, c},
{a, d}, {b, d}}, Sadm (F ) = {{}, {a}, {c}, {d}, {a, c}, {a, d}}, Scom (F ) = {{a},
{a, c}, {a, d}}, Sprf (F ) = {{a, c}, {a, d}}, Sstb (F ) = Ssst (F ) = {{a, d}}, and
Sgde (F ) = {{a}}. To conclude the example, we want to point out that argument
a is sceptically accepted with respect to the complete semantics, since it appears
in all three subsets of Scom (F ). On the other hand, arguments c, that is in just
one complete extension, is credulously accepted with respect to the complete
semantics.
Fig. 1. Example of abstract argumentation framework.
Many of the above-mentioned semantics (such as the admissible and the com-
plete ones) exploit the notion of defence in order to decide whether an argument
is part of an extension or not. The phenomenon for which an argument is ac-
cepted in some extension because it is defended by another argument belonging
to that extension is known as reinstatement [12]. In the same paper, Caminada
also gives a definition for a reinstatement labelling.
Definition 5 (Reinstatement labelling). Let F = hArg, Ri be an AF and
L = {in, out, undec}. A labelling of F is a total function L : Arg → L. We
define in(L) = {a ∈ Arg | L(a) = in}, out(L) = {a ∈ Arg | L(a) = out}
and undec(L) = {a ∈ Arg | L(a) = undec}. We say that L is a reinstatement
labelling if and only if it satisfies the following:
– ∀a ∈ Arg : a ∈ in(L) ⇐⇒ ∀b ∈ Arg | (b, a) ∈ R : b ∈ out(L)
– ∀a ∈ Arg : a ∈ out(L) ⇐⇒ ∃b ∈ Arg | (b, a) ∈ R ∧ b ∈ in(L)
Fig. 2. Example of reinstatement labelling.
In other words, an argument is labelled in if all its attackers are labelled
out, and it is labelled out if at least an in node attacks it. In all other cases,
the argument is labelled undec. A labelling-based semantics [1] associates with
an AF a subset of all the possible labellings. In Figure 2 we show an example
of reinstatement labelling on an AF in which arguments a and c highlighted in
green are in, red ones (b and d) are out, and the the yellow argument e (that
attacks itself) is undec.
Table 1. Reinstatement labelling vs semantics.
Labelling restrictions Semantics
no restrictions complete
empty undec stable
minimal undec semi-stable
maximal in preferred
maximal out preferred
maximal undec grounded
minimal in grounded
minimal out grounded
Given a labelling L, it is possible to identify a correspondence with the
extension-based semantics [1]. In particular, the set of in arguments coincides
with a complete extension, while other semantics can be obtained through re-
strictions on the labelling as shown in Table 1.
The notion of time can be included into the reasoning model of AFs by
considering temporal intervals [15] defined as follows.
Definition 6 (Temporal Interval). A temporal interval is a pair built from
t1 , t2 ∈ Z in one of the following ways:
– [t1 , t1 ], denoting the moment t1 ;
– [t1 , ∞), a set of moments formed by all the numbers in Z greater than or
equal to t1 ;
– (−∞, t2 ], a set of moments formed by all the numbers in Z smaller than or
equal to t2 ;
– [t1 , t2 ], a set of moments formed by all the numbers in Z from t1 to t2 (both
included);
– (−∞, ∞), denoting a set of moments formed by all the numbers in Z.
The set of all the intervals defined over Z ∪ {−∞, ∞} is denoted Υ .
In Timed Argumentation Frameworks [14,15], each argument is associated
with temporal intervals that express the period of time in which the argument
is available.
Definition 7 (TAFs). A timed abstract argumentation framework is a tuple
hArg, R, Avi where Arg ⊆ U is a set of adopted arguments belonging to the uni-
verse U , R5 is a binary relation on Arg, and Av : Arg → ℘(Υ ) is the availability
function for timed arguments.
We illustrate in Figure 3 an example of the behaviour of timed arguments
taken from [15], with availability function defined as Av(a) = {[10, 40], [60, 75]},
Av(b) = {[30, 50]}, Av(c) = {[20, 40], [45, 55], [60, 70]}, Av(d) = {[47, 65]} and
Av(e) = {(−∞, 44]}. Note that attack relations in a TAF never change, but
are only considered when availability of both the attacker and the attacked
arguments overlaps (alternatively, we can consider attacks to blink together with
the arguments they connect). We can imagine the modifications at a given instant
t taking place simultaneously, as if every argument of the TAF was handled
(made available/not available) by a different agent.
10 40 60 75
a
30 50
b
20 40 45 55 60 70
c
47 65
d
44
e
time
Fig. 3. Example of timed abstract argumentation framework.
Given a semantics σ, the set of acceptable arguments in a TAF can be com-
puted with respect to a certain moment t by only considering arguments (and
attacks) available at t. For example, in the TAF of Figure 3, the singleton {b}
is an admissible extension for t ∈ (41, 44), that is when b itself is available and
its attacker c is not.
5
Note that in certain time intervals, attacks could be defined between arguments not
currently available in the TAF.
3 tcla Syntax and Semantics
The syntax of our Timed Concurrent Language for Argumentation, tcla, is pre-
sented in Table 2, where, as usual, P , C, A and E denote a generic process, a
sequence of procedure declarations (or clauses), a generic agent and a generic
guarded agent, respectively. Moreover t ∈ N ∪ {+∞}. In Tables 3 and 4, then,
we give the definitions for the transition rules.
P ::= C.A
C ::= p(a, l, σ, i) :: A | C.C
A ::= success | f ailure | add(Arg, R) → A | rmv(Arg, R) → A | E | AkA | ∃x A |
p(a, l, σ, i)
E ::= testc,t (a, l, σ) → A | tests,t (a, l, σ) → A | checkt (Arg, R) → A | E + E |
E +P E | EkG E
Table 2. tcla syntax.
Communication between tcla agents is implemented via shared memory, sim-
ilarly to cla [5] and CC [26], and opposed to other languages (e.g., CSP [19] and
CCS [23]) based on message passing. In the following, we denote by E the class
of guarded agents and by E0 the class of guarded agents such that all outermost
guards have t = 0 (note that a Boolean syntactic category could be introduced
in replacement of E0 to better handle guards and allow for finer distinctions). In
a tcla process P = C.A, A is the initial agent, to be executed in the context of
the set of declarations C.
The operational model of tcla processes can be formally described by a transi-
tion system T = (Conf , −→), where we assume that each transition step exactly
takes one time-unit. Configurations (in) Conf are pairs consisting of a process
and an AF F = hArg, Ri representing the common knowledge base. The tran-
sition relation −→⊆ Conf × Conf is the least relation satisfying the rules in
Tables 3 and 4, and it characterises the (temporal) evolution of the system. So,
hA, F i −→ hA0 , F 0 i means that, if at time t we have the process A and the
framework F , then at time t + 1 we have the process A0 and the framework F 0 .
In Tables 3 and 4 we have omitted the symmetric rules for the choice oper-
ator + and for the two parallel composition operators k and kG . Indeed, + is
commutative, so E1 + E2 produces the same result as (that is, is congruent to)
E2 + E1 . The same is also true for k and kG . Note that +, k and kG are also
associative. Moreover success and f ailure are the identity and the absorbing
elements under the parallel composition k, respectively (namely for each agent
A, we have that Aksuccess and Akf ailure are the agents A and f ailure, re-
spectively). In the following, we will usually write a tcla process P = C.A as the
corresponding agent A, omitting C when not required by the context.
hadd(Arg 0 , R0 ) → A, hArg, Rii −→ hA, hArg ∪ Arg 0 , R ∪ R00 ii
Ad
where R00 = {(a, b) ∈ R0 | a, b ∈ Arg ∪ Arg 0 }
hrmv(Arg 0 , R0 ) → A, hArg, Rii −→ hA, hArg \ Arg 0 , R \ {R0 ∪ R00 }ii
Re
where R00 = {(a, b) ∈ R | a ∈ Arg 0 ∨ b ∈ Arg 0 }
Arg 0 ⊆ Arg ∧ R0 ⊆ R t > 0
Ch (1)
hcheckt (Arg 0 , R0 ) → A, hArg, Rii −→ hA, hArg, Rii
Arg 0 6⊆ Arg ∨ R0 6⊆ R t > 0
Ch (2)
hcheckt (Arg 0 , R0 ) → A, hArg, Rii −→ hcheckt−1 (Arg 0 , R0 ) → A, hArg, Rii
hcheck0 (Arg 0 , R0 ) → A, F i −→ hf ailure, F i Ch (3)
∃L ∈ Sσ (F ) | l ∈ L(a) t > 0
CT (1)
htestc,t (a, l, σ) → A, F i −→ hA, F i
∀L ∈ Sσ (F ).l 6∈ L(a) t > 0
CT (2)
htestc,t (a, l, σ) → A, F i −→ htestc,t−1 (a, l, σ) → A, F i
htestc,0 (a, l, σ) → A, F i −→ hf ailure, F i CT (3)
∀L ∈ Sσ (F ).l ∈ L(a) t > 0
ST (1)
htests,t (a, l, σ) → A, F i −→ hA, F i
∃L ∈ Sσ (F ) | l 6∈ L(a) t > 0
ST (2)
htests,t (a, l, σ) → A, F i −→ htests,t−1 (a, l, σ) → A, F i
htests,0 (a, l, σ) −→ A, F i −→ hf ailure, F i ST (3)
hE1 , F i −→ hA1 , F i, E1 6∈ E0 , A1 6∈ E
If (1)
hE1 +P E2 , F i −→ hA1 , F i
hE1 , F i −→ hE10 , F i, E1 6∈ E0 , E10 ∈ E E1 ∈ E0 , hE2 , F i −→ hA2 , F i
If (2)
hE1 +P E2 , F i −→ hE10 +P E2 , F i hE1 +P E2 , F i −→ hA2 , F i
Table 3. tcla operational semantics (part 1/2).
hE1 , F i −→ hA1 , F i, hE2 , F i −→ hA2 , F i, E1 , E2 6∈ E0 , A1 6∈ E
GP (1)
hE1 kG E2 , F i −→ hA1 kA2 , F i
hE1 , F i −→ hE10 , F i, hE2 , F i −→ hE20 , F i, E1 , E2 6∈ E0 , E10 , E20 ∈ E
GP (2)
hE1 kG E2 , F i −→ hE10 kG E20 , F i
E1 ∈ E0 , hE2 , F i −→ hA2 , F i
GP (3)
hE1 kG E2 , F i −→ hA2 , F i
hA1 , F i −→ hA01 , F 0 i, hA2 , F i −→ hA02 , F 00 i
Pa
hA1 kA2 , F i −→ hA01 kA02 , ∗(F, F 0 , F 00 )i
hE1 , F i −→ hA1 , F i, E1 6∈ E0 , A1 6∈ E E1 ∈ E0 , hE2 , F i −→ hA2 , F i
ND (1)
hE1 + E2 , F i −→ hA1 , F i hE1 + E2 , F i −→ hA2 , F i
hE1 , F i −→ hE10 , F i, hE2 , F i −→ hE20 , F i, E1 , E2 6∈ E0 , E10 , E20 ∈ E
ND (2)
hE1 + E2 , F i −→ hE10 + E20 , F i
hA[y/x], F i −→ hA0 , F 0 i
with y ∈ U \ Arg HA
h∃x A, F i −→ hA0 , F 0 i
hp(b, m, γ, j), F i −→ hA[b/a, m/l, γ/σ, j/i], F i when p(a, l, σ, i) :: A PC
Table 4. tcla operational semantics (part 2/2).
Suppose we have an agent A whose knowledge base is represented by a frame-
work F = hArg, Ri. An add(Arg 0 , R0 ) action performed by the agent results in
the addition of a set of arguments Arg 0 ⊆ U (where U is the universe) and
a set of relations R0 to the AF F . When performing an addition, (possibly)
new arguments are taken from U \ Arg. We want to make clear that the tuple
(Arg 0 , R0 ) is not an AF, indeed it is possible to have Arg 0 = ∅ and R0 6= ∅.
However, the structure of the shared store after an add operation is guaranteed
to be an AF compliant with Definition 1, since only attacks between arguments
in Arg ∪ Args0 are added to R.
Intuitively, rmv(Arg, R) allows to specify arguments and/or attacks to be
removed from the knowledge base. The removal of an argument from an AF
also involves removing all attack relations outgoing from and incoming to that
argument, thus making F preserve the structure of an AF. Trying to remove an
argument (or an attack) which does not exist in F will have no consequences.
The testc,t (a, l, σ) → A, tests,t (a, l, σ) → A and checkt (Arg, R) → A con-
structs are explicit timing primitives that allow for the specification of timeouts.
In fact, in timed applications often one cannot wait indefinitely for an event.
Thus, a timed language should allow us to specify that, in case a given time
bound is exceeded (i.e. a timeout occurs), the wait is interrupted and an alter-
native action is taken.
The operator checkt (Arg 0 , R0 ) (rules Ch (1)-(3) in Table 3) realises a timed
construct and is used to verify whether, in a given time interval, the specified
arguments and attack relations are contained in the set of arguments and attacks
of the knowledge base, without introducing any further change. If t > 0 and the
check is positive, the operation succeeds and the agent checkt (Arg 0 , R0 ) → A
can perform an action in the agent A (rule Ch (1)). If t > 0 but the check
is not satisfied, then the control is repeated at the next time instant and the
value of the counter t is decreased (rule Ch (2)). Axiom Ch (3) shows that, if
the timeout is exceeded, i.e., the counter t has reached the value of 0, then the
process checkt (Arg 0 , R0 ) → A fails.
The rules for credulous tests CT (1)-(3) and sceptical tests SC (1)-(3) in
Table 3 are similar to rules Ch (1)-(3) described before. Observe that we have two
distinct test operations, both requiring the specification of an argument a ∈ Arg,
a label l ∈ {in, out, undec}6 and a semantics σ ∈ {adm, com, stb, sst, prf, gde}.
The credulous testc (a, l, σ) succeeds if there exists at least one extension of Sσ (F )
whose corresponding labelling L is such that L(a) = l. Similarly, the sceptical
tests (a, l, σ) succeeds if a is labelled l in all possible labellings L ∈ Sσ (F ).
The operator +P (If (1)-(2) in Table 3) is left-associative and realises an
if-then-else construct: if we have E1 +P E2 (with E1 , E2 ∈ E) and the guards of
E1 succeed, than E1 will be always chosen over E2 , even if also the guards of E2
succeed. So, in order for E2 to be selected, it has to be the only one such that
its guards succeed and will be selected only after E1 fails. If the guards of E1 do
not fail, the execution can either move to any consequent agent A1 which does
not belong to E, or proceed with E10 +P E2 ∈ E.
The guarded parallelism GP (1)-(3) in Table 4 is designed to allow all the
operations for which the guards in the inner expression are satisfied. In more
detail, the guards of E1 kG E2 succeed when either the guards of E1 , E2 or both
succeed and all the operations that can be executed are executed. This behaviour
is different both from classical parallelism (for which all the agents have to
succeed in order for the parallel agent to succeed) and from nondeterminism
(that only selects one branch).
The remaining operators are classical concurrency compositions: the rule
parallelism Pa in Table 4 models the parallel composition operator in terms
of maximal parallelism. By transition rules, an agent in a parallel composition
obtained through k succeeds only if all the agents succeed. In our implementation
of rule Pa, we use ∗(F, F 0 , F 00 ) := (F 0 ∩ F 00 ) ∪ ((F 0 ∪ F 00 ) \ F ) to handle parallel
additions and removals of arguments7 . In particular, if an argument a is added
and removed at the same moment (e.g., trough the program add({a}, {}) →
success k rmv({a}, {}) → success), we have two possible outcomes: if a was not
6
Other labelling semantics could be considered where undec arguments are further
divided into “don’t know” and “don’t care” [7].
7
Union, intersection and difference between AFs are intended as the union, intersec-
tion and difference of their sets of arguments and attacks, respectively.
present in the knowledge base, then the add operation gains priority over the
rmv one, since a ∈ ((F 0 ∪ F 00 ) \ F ); on the other hand, when a was already in
the shared memory, we have that a 6∈ ((F 0 ∪ F 00 ) \ F ), and a is removed.
Any agent composed through + (rules ND (1)-(2)) is chosen if its guards
succeed; the existential quantifier ∃x A of rule HA behaves like agent A where
variables (arguments) in x are local to A. The procedure call (rule PC) has four
parameters that allow the implementation of operators which takes into account
an argument, a semantic label (in/out/undec), a semantics σ and a time interval
i, respectively.
In the following we provide the definition for the observables of the language,
which considers the traces of successful or failed terminating computations that
the agent A can perform for each tcla process P = C.A. Given a transition
relation −→, we denote by −→∗ its reflexive and transitive closure.
Definition 8 (Observables for tcla). Let P = C.A be a tcla process. We
define
Oio (P ) = {F1 · · · Fn · ss | hA, F1 i−→∗ hsuccess, Fn i} ∪
{F1 · · · Fn · ff | hA, F1 i−→∗ hf ailure, Fn i}.
4 Modelling TAFs
In the context of argumentation, the possibility to include time in the reason-
ing processes conducted by intelligent agents allows for modelling dynamic be-
haviours, such as, for instance, the addition and the removal of information at
precise moments from a knowledge base.
Agents using tcla constructs and availability functions in TAFs regulate the
existence of arguments in a similar way; in particular, we can imagine each agent
having control over an argument of the TAF. This result is showed by providing
explicitly a translation from a TAF into a tcla process.
In the following, given I ⊆ Υ , I is ordered if there is no [t1 , t2 ] ∈ I such
that t2 < t1 and for each i1 , i2 ∈ I, we have that i1 and i2 are disjoint and
non-consecutive. Without loss of generality, we consider only ordered sets of
intervals. Moreover, given I 6= ∅ we denote by
(−∞, +∞) if (−∞, +∞) ∈ I
(−∞, t] if (−∞, t] ∈ I
f irst(I) =
[t, +∞) if {[t, +∞)} = I
[t1 , t2 ] otherwise
where [t1 , t2 ] ∈ I is such that for each T 0 ∈ I, where T 0 = [t01 , t02 ] or T 0 = [t01 +∞),
t1 < t01 . Moreover, we denote by continue(I) = I \ f irst(I).
Finally, given a ∈ Arg and a binary relation R defined over Arg, we denote
by R|a = {(a, b) | (a, b) ∈ R} ∪ {(b, a) | (b, a) ∈ R}. To ease the translation, we
use sleep(t) → A, with t ≥ 0, as a shortcut for
(
A if t ≤ 0
check1 ({}, {}) → (sleep(t − 1) → A) otherwise
The agent sleep(t) → A, with t ≥ 0, executes the check operation for exactly
t times and then the agent A is executed. Practically, sleep(t) lets the agent A
wait for t instants of time.
In the following we assume that for each [t1 , t2 ] ∈ S, t1 > 0.
Definition 9 (Translation). The translation of a TAF h{a1 , . . . , an }, R, Avi
is
T (h{a1 , . . . , an }, R, Avi) = Tadd (0, a1 , R|a1 , Av(a1 ))k · · · kTadd (0, an , R|an , Av(an ))
where
success if S = ∅
add({a}, R) → success if S = {(−∞, +∞)}
Tadd (t, a, R, S) =
sleep(tin − t − 1) →
(add({a}, R) → Trmv (t, a, R, S)) otherwise
and
success if S = {[t1 , +∞)}
f in − tin ) →
sleep(t
Trmv (t, a, R, S) =
(rmv({a}, {}) →
Tadd (tf in + 1, a, R, continue(S))) otherwise
where (
1 if f irst(S) = (−∞, t2 ]
tin =
t1 if f irst(S) = [t1 , t2 ] or f irst(S) = [t1 , +∞)
and tf in = t2 if f irst(S) = (−∞, t2 ] or f irst(S) = [t1 , t2 ].
Theorem 1. The translation T of a TAF produces a tcla program such that,
at any instant of time t > 0, the arguments in the store are all and only the
arguments available at t in the original TAF.
Corollary 1. Given a tcla program produced by a translation T of a TAF, the
set of arguments in the store accepted with respect to a semantics σ at a given
instant of time t > 0 coincides with the set of extensions identified by σ at
moment t on the original TAF .
Example 2. Consider the TAF of Figure 3. By following previous translation
T 0 , the availability of its timed arguments for each time instant t > 0 can be
simulated by a tcla process that modifies the store by adding and removing part
of the underlying framework. We use five agents in parallel (see Table 5), each
of which is in charge of handling one argument of the TAF. Synchronisation
between these agents is provided through the use of sleep constructs that handle
time lapsing. In the initial configuration, the shared memory is empty (F =
h{}, {}i).
sleep(9) → (add({a}, {(b, a), (d, a)}) → (sleep(30) → (rmv({a}, {}) →
(sleep(18) → (add({a}, {(b, a), (d, a)}) → (sleep(15) → (rmv({a}, {}) → success))))))) k
sleep(29) → (add({b}, {(b, a), (c, b)}) → (sleep(20) → (rmv({b}, {}) → success))) k
sleep(19) → (add({c}, {(c, b)}) → (sleep(20) → (rmv({c}, {}) →
(sleep(3) → (add({c}, {(c, b)}) → (sleep(10) → (rmv({c}, {}) →
(sleep(3) → (add({c}, {(c, b)}) → (sleep(10) → (rmv({c}, {}) → success))))))))))) k
sleep(46) → (add({d}, {(d, a), (e, d)}) → (sleep(18) → (rmv({d}, {}) → success))) k
add({e}, {(e, d)}) → (sleep(43) → (rmv({e}, {}) → success))
Table 5. tcla program realising the TAF of Figure 3 where each agent handles one
argument.
5 Related Work
This kind of frameworks has been studied from the point of view of dynamics
in works like [13,24], where the authors investigate the consequences brought by
modifications on AFs. Given the very nature of argumentation, it is reasonable
to assume that the interaction between interacting entities (being them people
or synthetic agents) are regulated by the passing of time [21,22].
Timed Abstract Dialectical Frameworks (tADFs) are introduced in [2] to
cope with acceptance conditions changing over time. Differently form TAFs,
which extend classical AFs with the notion of time intervals, tADFs use generic
statements that subsumes arguments and relations (not only including attacks,
but also, for instance, supports). Therefore, tADFs are not suitable for being
modelled through tcla processes, which, instead, relies on AFs.
6 Conclusion and Future Work
In this paper, we introduced tcla, an extension of cla in which time is taken
into account in the form of timeouts on expressions. We used maximal paral-
lelism to realise simultaneous execution of actions carried forward by different
agents. We presented the operational semantics, and showed examples of how
to instantiate TAF by using our language. As future work, we would like to
study time-dependent notions of acceptability. We could introduce operators for
checking if a given argument is acceptable in all (or in some) instants of time.
Quantitative temporal operators could, then, be defined to check acceptability
only in given intervals. We are also planning to provide a working implementa-
tion of tcla able to aid research and serve for application purposes.
References
1. Baroni, P., Caminada, M., Giacomin, M.: An introduction to argumentation
semantics. Knowl. Eng. Rev. 26(4), 365–410 (2011), https://doi.org/10.1017/
S0269888911000166
2. Baumann, R., Heinrich, M.: Timed abstract dialectical frameworks: A simple
translation-based approach. In: Prakken, H., Bistarelli, S., Santini, F., Tatic-
chi, C. (eds.) Computational Models of Argument - Proceedings of COMMA
2020, Perugia, Italy, September 4-11, 2020. Frontiers in Artificial Intelligence and
Applications, vol. 326, pp. 103–110. IOS Press (2020), https://doi.org/10.3233/
FAIA200496
3. Berry, G., Gonthier, G.: The esterel synchronous programming language: Design,
semantics, implementation. Sci. Comput. Program. 19(2), 87–152 (1992), https:
//doi.org/10.1016/0167-6423(92)90005-V
4. Bistarelli, S., Gabbrielli, M., Meo, M.C., Santini, F.: Timed soft concurrent con-
straint programs: An interleaved and a parallel approach. Theory Pract. Log. Pro-
gram. 15(6), 743–782 (2015), https://doi.org/10.1017/S1471068414000106
5. Bistarelli, S., Taticchi, C.: A concurrent language for argumentation. In: Fazz-
inga, B., Furfaro, F., Parisi, F. (eds.) Proceedings of the Workshop on Ad-
vances In Argumentation In Artificial Intelligence 2020, Online, November 25-26,
2020. CEUR Workshop Proceedings, vol. 2777, pp. 75–89. CEUR-WS.org (2020),
http://ceur-ws.org/Vol-2777/paper67.pdf
6. Bistarelli, S., Taticchi, C.: Introducing a tool for concurrent argumentation. In:
Faber, W., Friedrich, G., Gebser, M., Morak, M. (eds.) Logics in Artificial Intelli-
gence - 17th European Conference, JELIA 2021, Virtual Event, May 17-20, 2021,
Proceedings. Lecture Notes in Computer Science, vol. 12678, pp. 18–24. Springer
(2021), https://doi.org/10.1007/978-3-030-75775-5 2
7. Bistarelli, S., Taticchi, C.: A unifying four-state labelling semantics for bridging
abstract argumentation frameworks and belief revision. In: Proceedings of the 22nd
Italian Conference on Theoretical Computer Science, Bologna, Italy, September
13-15, 2021. CEUR Workshop Proceedings, CEUR-WS.org (2021), to appear
8. de Boer, F.S., Gabbrielli, M., Meo, M.C.: A timed concurrent constraint language.
Inf. Comput. 161(1), 45–83 (2000), https://doi.org/10.1006/inco.1999.2879
9. de Boer, F.S., Gabbrielli, M., Meo, M.C.: Proving correctness of timed concurrent
constraint programs. ACM Trans. Comput. Log. 5(4), 706–731 (2004), https://
doi.org/10.1145/1024922.1024926
10. Budán, M.C., Lucero, M.J.G., Chesñevar, C.I., Simari, G.R.: Modeling time and
valuation in structured argumentation frameworks. Inf. Sci. 290, 22–44 (2015),
https://doi.org/10.1016/j.ins.2014.07.056
11. Busi, N., Gorrieri, R., Zavattaro, G.: Process calculi for coordination: From linda
to javaspaces. In: Rus, T. (ed.) Algebraic Methodology and Software Technology.
8th International Conference, AMAST 2000, Iowa City, Iowa, USA, May 20-27,
2000, Proceedings. Lecture Notes in Computer Science, vol. 1816, pp. 198–212.
Springer (2000), https://doi.org/10.1007/3-540-45499-3 16
12. Caminada, M.: On the issue of reinstatement in argumentation. In: Fisher, M.,
van der Hoek, W., Konev, B., Lisitsa, A. (eds.) Logics in Artificial Intelligence,
10th European Conference, JELIA 2006, Liverpool, UK, September 13-15, 2006,
Proceedings. Lecture Notes in Computer Science, vol. 4160, pp. 111–123. Springer
(2006), https://doi.org/10.1007/11853886 11
13. Cayrol, C., de Saint-Cyr, F.D., Lagasquie-Schiex, M.: Change in abstract argumen-
tation frameworks: Adding an argument. J. Artif. Intell. Res. 38, 49–84 (2010),
https://doi.org/10.1613/jair.2965
14. Cobo, M.L., Martı́nez, D.C., Simari, G.R.: On admissibility in timed abstract
argumentation frameworks. In: Coelho, H., Studer, R., Wooldridge, M.J. (eds.)
ECAI 2010 - 19th European Conference on Artificial Intelligence, Lisbon, Portu-
gal, August 16-20, 2010, Proceedings. Frontiers in Artificial Intelligence and Ap-
plications, vol. 215, pp. 1007–1008. IOS Press (2010), https://doi.org/10.3233/
978-1-60750-606-5-1007
15. Cobo, M.L., Martı́nez, D.C., Simari, G.R.: On semantics in dynamic argumentation
frameworks. In: XVIII Congreso Argentino de Ciencias de la Computación (2013),
http://sedici.unlp.edu.ar/handle/10915/31428
16. Dung, P.M.: On the acceptability of arguments and its fundamental role in non-
monotonic reasoning, logic programming and n-person games. Artif. Intell. 77(2),
321–358 (1995), https://doi.org/10.1016/0004-3702(94)00041-X
17. Halbwachs, N., Lagnier, F., Ratel, C.: Programming and verifying real-time sys-
tems by means of the synchronous data-flow language LUSTRE. IEEE Trans.
Software Eng. 18(9), 785–793 (1992), https://doi.org/10.1109/32.159839
18. Harel, D.: Statecharts: A visual formalism for complex systems. Sci. Comput. Pro-
gram. 8(3), 231–274 (1987), https://doi.org/10.1016/0167-6423(87)90035-9
19. Hoare, C.A.R.: Communicating sequential processes. Commun. ACM 21(8), 666–
677 (1978), https://doi.org/10.1145/359576.359585
20. Le Guernic, P., Gautier, T., Le Borgne, M., Le Maire, C.: Programming real-time
applications with signal. Proc. IEEE 79(9), 1321–1336 (1991), https://doi.org/10.
1109/5.97301
21. Mann, N., Hunter, A.: Argumentation using temporal knowledge. In: Besnard,
P., Doutre, S., Hunter, A. (eds.) Computational Models of Argument: Proceed-
ings of COMMA 2008, Toulouse, France, May 28-30, 2008. Frontiers in Arti-
ficial Intelligence and Applications, vol. 172, pp. 204–215. IOS Press (2008),
http://www.booksonline.iospress.nl/Content/View.aspx?piid=9281
22. Marcos, M.J., Falappa, M.A., Simari, G.R.: Dynamic argumentation in abstract
dialogue frameworks. In: McBurney, P., Rahwan, I., Parsons, S. (eds.) Argu-
mentation in Multi-Agent Systems - 7th International Workshop, ArgMAS 2010,
Toronto, ON, Canada, May 10, 2010 Revised, Selected and Invited Papers. Lec-
ture Notes in Computer Science, vol. 6614, pp. 228–247. Springer (2010), https:
//doi.org/10.1007/978-3-642-21940-5 14
23. Milner, R.: A Calculus of Communicating Systems, Lecture Notes in Computer
Science, vol. 92. Springer (1980), https://doi.org/10.1007/3-540-10235-3
24. Rotstein, N.D., Moguillansky, M.O., Falappa, M.A., Garcı́a, A.J., Simari, G.R.:
Argument theory change: Revision upon warrant. In: Besnard, P., Doutre, S.,
Hunter, A. (eds.) Computational Models of Argument: Proceedings of COMMA
2008, Toulouse, France, May 28-30, 2008. Frontiers in Artificial Intelligence and
Applications, vol. 172, pp. 336–347. IOS Press (2008), http://www.booksonline.
iospress.nl/Content/View.aspx?piid=9292
25. Saraswat, V.A., Jagadeesan, R., Gupta, V.: Timed default concurrent constraint
programming. J. Symb. Comput. 22(5/6), 475–520 (1996), https://doi.org/10.
1006/jsco.1996.0064
26. Saraswat, V.A., Rinard, M.C.: Concurrent constraint programming. In: Allen, F.E.
(ed.) Conference Record of the Seventeenth Annual ACM Symposium on Principles
of Programming Languages, San Francisco, California, USA, 1990. pp. 232–245.
ACM Press (1990), https://doi.org/10.1145/96709.96733