*Article* **Knowledge Dynamics and Behavioural Equivalences in Multi-Agent Systems**

**Bogdan Aman 1,2 and Gabriel Ciobanu 2,\***


**Abstract:** We define a process calculus to describe multi-agent systems with timeouts for communication and mobility able to handle knowledge. The knowledge of an agent is represented as sets of trees whose nodes carry information; it is used to decide the interactions with other agents. The evolution of the system with exchanges of knowledge between agents is presented by the operational semantics, capturing the concurrent executions by a multiset of actions in a labelled transition system. Several results concerning the relationship between the agents and their knowledge are presented. We introduce and study some specific behavioural equivalences in multi-agent systems, including a knowledge equivalence able to distinguish two systems based on the interaction of the agents with their local knowledge.

**Keywords:** mobile agents; timeouts; knowledge as set of trees; behavioural equivalences

**Citation:** Aman, B.; Ciobanu, G. Knowledge Dynamics and Behavioural Equivalences in Multi-Agent Systems. *Mathematics* **2021**, *9*, 2869. https://doi.org/ 10.3390/math9222869

Academic Editor: Liliya Demidova

Received: 25 September 2021 Accepted: 8 November 2021 Published: 11 November 2021

**Publisher's Note:** MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

**Copyright:** © 2021 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https:// creativecommons.org/licenses/by/ 4.0/).

#### **1. Introduction**

Process calculi are used to describe concurrent systems, providing a high-level description of interactions, communications and synchronizations between independent processes or agents. The main features of a process calculus are: (i) interactions between agents/processes are by communication (message-passing), rather than modifying shared variables; (ii) large systems are described in a compositional way by using a small number of primitives and operators; (iii) processes can be manipulated by using equational reasoning and behavioural equivalences. The key primitive distinguishing the process calculi from other models of computation is the parallel composition. The compositionality offered by the parallel composition can help to describe large systems in a modular way, and to better organize their knowledge (for reasoning about them).

In this paper we define an extension of the process calculus TIMO [1] in order to model multi-agent systems and their knowledge. In this framework, the agents can move between locations and exchange information, having explicit timeouts for both migration and communication. Additionally, they have a knowledge of the network used to decide the next interactions with other agents. The knowledge of the agents is inspired by a model of semi-structured data [2] in which it is given by sets of unordered trees containing pairs of labels and values in each node. In our approach, the knowledge is described via sets of trees used to exchange information among agents about migration and communication. Overall, we present a formal way to describe the behaviour of mobile communicating agents and networks of agents in a compositional manner.

A network of mobile agents is a distributed environment composed of locations where several agents act in parallel. Each agent is represented by a process together with its knowledge that is used to decide interactions with other agents. Taking the advantage that there already exists a theory of parallel and concurrent systems, we define a prototyping language for multi-agent systems presented as a process calculus in concurrency theory. Its semantics is given formally by a labelled transition system; in this way we describe the behaviour of the entire network, and prove some useful properties.

In concurrency, the behavioural equality of two systems is captured by using bisimulations. Bisimulations are important contributions to computer science that appeared as refinements of 'structure-preserving' mappings (morphisms) in mathematics; they can be applied to new fields of study, including multi-agent systems. Bisimilarity is the finest behavioural equivalence; it abstracts from certain details of the systems, focusing only on the studied aspects. The equivalence relations should be compositional such that if two systems are equivalent, then the systems obtained by their compositions with a third system should also be equivalent. This compositional reasoning allows for the development of complex systems in which each component can be replaced by an equivalent one. Furthermore, there exist efficient algorithms for bisimilarity checking and compositionality properties of bisimilarity, algorithms that are usually used to minimize the state-space of systems. These are good reasons why we consider that it is important to define and study some specific behavioural equivalences for multi-agent systems enhanced with a knowledge of the network for deciding the next interactions. To be more realistic, we consider systems of agents with timing constraints on migration and communication. Therefore, a notable advantage of using our framework to model systems of mobile agents is the possibility to naturally express compositionality, mobility, local communication, timeouts, knowledge, and equivalences between systems in a given interval of time (up to a timeout).

The paper is structured as follows: Section 2 presents the syntax and semantics of the new process calculus knowTIMO and provides some results regarding the timing and knowledge aspects of the evolution. In Section 3 we define and study various bisimulations for the multi-agent systems described in knowTIMO . The conclusion, related work and references end the article.

#### **2. The New Process Calculus knowTIMO**

In order to model the evolution of multi-agent systems handling knowledge, timed communication and timed migration, we define a process calculus named knowTIMO , where know stands for 'knowledge' and TIMO stands for the family of calculi introduced in [1] and developed in several articles.

In Table 1 we present the syntax of knowTIMO, where:


An agent *A* is a pair *P* - *K*, where *A* behaves as prescribed by *P* and *K* is the knowledge used by process *<sup>P</sup>* during its execution. An agent *<sup>A</sup>* <sup>=</sup> go*<sup>t</sup> <sup>l</sup>* then *<sup>P</sup>* - *K* is ready to migrate from its current location to the location *<sup>l</sup>* by consuming the action go*<sup>t</sup> <sup>l</sup>* of agent *<sup>A</sup>*. In go*<sup>t</sup>* , the timer *t* indicates the fact that agent *A* is unavailable for *t* units of time at the current location; then, once the timer *<sup>t</sup>* expires, go*<sup>t</sup> <sup>l</sup>* then *<sup>P</sup>* executes process *<sup>P</sup>* at the new location *<sup>l</sup>*. Since *l* can be a location variable, it may be instantiated after communication between agents. The use of location variables allows agents to adapt their behaviours based on the interactions among agents.

An agent *A* = *a*Δ*<sup>t</sup>* ! *<sup>v</sup>* then *<sup>P</sup>* else *<sup>Q</sup>* - *K* is available for up-to *t* units of time to communicate on channel *a* the value *v* to another agent *A* = *a*Δ*<sup>t</sup>* ?(*u*) then *<sup>P</sup>* else *<sup>Q</sup>* - *K* available for communication at the same location and awaiting for a value on the same communication channel *a*. In order to simplify the presentation in this paper, we consider a

synchronous calculus; this means that when a communication takes place, the message sent by one process is instantly received by the other process. If the communication happens, then agent *A* executes process *P*, while agent *A* executes process *P* by making use of the received value *v*. If the timers *t* and *t* of the agents *A* and *A* expire, then they execute processes *Q* and *Q* , respectively.

**Table 1.** Syntax of our Multi-Agent Systems.


An agent *<sup>A</sup>* <sup>=</sup> if *test* then *<sup>P</sup>* else *<sup>Q</sup>* - *K* uses its knowledge *K* to check the truth value of the *test*. If the value is *true*, then agent *A* executes process *P*, while if the value is *false*, then agent *A* executes process *Q*.

The agent *<sup>A</sup>* = *create*( *<sup>f</sup>* | *<sup>v</sup>*; <sup>∅</sup>) then *<sup>P</sup>* - *K* extends its knowledge *K* by adding the new piece of knowledge *f* | *v*; ∅ in parallel with *K*, and then executes process *P*. The agent *<sup>A</sup>* = *update*(*p*/*f*, *<sup>v</sup>*) then *<sup>P</sup>* - *K* updates its knowledge *K* by adding the value *v* into the field identified by *f* reached following path *p*/ *f* , and then executes process *P*; if the field *f* does not exist, then the field is created and the value *v* is assigned to it. The agent *<sup>A</sup>* = <sup>0</sup> -*K* has no actions to execute, and its evolution terminates.

The knowledge *K* of an agent *A* is used either for storing information needed for communication with other agents or for deciding what process to execute. We define the knowledge as sets of trees in which the nodes carrying the information are of two types: *f* | *ε*; *K* and *f* | *v*; *K* . Both types of nodes contain a field *f* and a knowledge *K* ; they differ only in the value stored in the field *f* , which can be either the symbol *ε* indicating the empty value, or a non-empty value *<sup>v</sup>*. An agent *<sup>A</sup>* = *<sup>P</sup>* - *K* can use the information stored in its knowledge *K* to perform tests. For example, a test *K*(*p*/ *f*) > *k* is *true* only if, following a path *p* in knowledge *K*, the value stored in the field *f* is greater than *k* (otherwise, it is evaluated to *false*); a path is used to select a node in knowledge *K*. Predicates, always embedded in square brackets and attached to fields in a path, are used to analyze either the value of the current node by using *p*[*test*(*p*)] or the values of the inner nodes by using *p*[*test*(*p*/*f*)]. We say that a knowledge *K* is included in another knowledge *K* (denoted *K* ⊆ *K* ) if for all paths *p* appearing in *K* it holds that *K*(*p*) = *K* (*p*).

In Table 1 there exist only one possibility to bind variables; namely, the variable *u* of the process *a*Δ*<sup>t</sup>* ?(*u*) then *<sup>P</sup>* else *<sup>Q</sup>* is bound within process *<sup>P</sup>*, while it is not bound within process *Q*. We denote by *fv*(*P*) and *fv*(*N*) the sets of free variables appearing in process *P* and network *N*, respectively. Moreover, we impose that *fv*(*Pid*) ⊆ {*u1*, ... , *umid* }, where *id*(*u1*, ... , *umid* ) *def* = *Pid*. We denote by {*v*/*u*}*P* the process *P* having all the free occurrences of the variable *u* replaced by value *v*, possibly after using *α*-conversion to avoid name clashes in process *P*.

A network is composed of distributed locations, where *l*[[*A*˜]] denotes a location *l* containing a set *A*˜ of agents, while *l*[[**0**]] denotes a location without any agents. Over the set N of networks we define the structural equivalence ≡ as the smallest congruence satisfying the equalities:

$$\begin{array}{c} l[[\varvarprojlim N] \equiv l[[\varvarprojlim]] \quad l[[\varvarprojlim]] \quad l[[\varinjlim]] \equiv l[[\varvarprojlim] \quad \varinjlim] \quad \surcurlyeq l[\varinjlim] \\ N \equiv N \quad N \mid N' \equiv N' \mid N \quad \text{( $N \mid N'$ )} \mid N'' \equiv N \mid (N' \mid N'') \; . \end{array}$$

The structural congruence ≡ is needed when using the *operational semantics* presented in Tables 2 and 3 for either executing actions or indicating time passing. In Table 2 the relation *<sup>N</sup>* <sup>Λ</sup> −→ *N* denotes the transformation of a network *N* into a network *N* by executing the actions from the multiset of actions Λ; if the multiset of actions Λ contains only a single

action *<sup>λ</sup>*, namely <sup>Λ</sup> <sup>=</sup> {*λ*}, then we use *<sup>N</sup> <sup>λ</sup>* −→ *<sup>N</sup>* instead of *<sup>N</sup>* {*λ*} −−→ *<sup>N</sup>* .

The operational semantics of knowTIMO is presented in Table 2.


**Table 2.** Operational Semantics for our Multi-Agent Systems

In rule (STOP), *l*[[**0**]] denotes a network without agents, and thus −→ marks the fact that no action is available for execution. Rule (COM) is used if at location *l* two agents *<sup>A</sup>*<sup>1</sup> <sup>=</sup> *<sup>a</sup>*Δ*t*<sup>1</sup> ! *<sup>v</sup>* then *<sup>P</sup>*<sup>1</sup> else *<sup>Q</sup>*<sup>1</sup> - *<sup>K</sup>*<sup>1</sup> and *<sup>A</sup>*<sup>2</sup> <sup>=</sup> *<sup>a</sup>*Δ*t*<sup>2</sup> ?(*u*) then *<sup>P</sup>*<sup>2</sup> else *<sup>Q</sup>*<sup>2</sup> - *K*<sup>2</sup> can communicate successfully over channel *a*. After communication, both agents remain at the current location *l* with their knowledge unchanged; agent *A*<sup>1</sup> executes *P*1, while agent *A*<sup>2</sup> executes {*v*/*u*}*P*2. The successful communication over channel *a* at location *l* is marked by label *a*!?@*l*.

Rules (PUT0) and (GET0) are used for an agent *<sup>A</sup>* <sup>=</sup> *<sup>a</sup>*Δ<sup>0</sup> <sup>∗</sup> then *<sup>P</sup>* else *<sup>Q</sup>* - *K* (where ∗∈{! *v*, ?(*u*)}) to remove action *a* when its timer expires. Afterwards, agent *A* is ready to execute *Q*. Knowledge K remains unchanged. Since rule (COM) can be applied even if *t*<sup>1</sup> and *t*<sup>2</sup> are zero, it follows that when a timer is 0, only one of the rules (COM), (PUT0) and (GET0) is chosen for application in a nondeterministic manner.

Rule (MOVE0) is used when at location *<sup>l</sup>* an agent *<sup>A</sup>* <sup>=</sup> go<sup>0</sup> *<sup>l</sup>* then *<sup>P</sup>* - *K* migrates to location *l* to execute process *P*. Rules (IFT) and (IFF) are used when an agent *<sup>A</sup>* <sup>=</sup> if *test* then *<sup>P</sup>* else *<sup>Q</sup>* - *K* should decide what process to execute (*P* or *Q*) based on the Boolean value returned by *test*@*K*; this value is determined by performing the *test* on the knowledge *K* of agent *A*. Notice that in order to perform a *test*, the agent *A* can only read its knowledge *K*.

Rule (CREATE) is used when an agent *<sup>A</sup>* <sup>=</sup> *create*( *<sup>f</sup>* <sup>|</sup> *<sup>v</sup>*; <sup>∅</sup>) then *<sup>P</sup>* - *K* extends its knowledge *K* with *f* | *v*; ∅; afterwards, the agent *A* executes process *P*.

Rule (UPDATE) is used when an agent *<sup>A</sup>* <sup>=</sup> *update*(*p*/*f*, *<sup>v</sup>*) then *<sup>P</sup>* - *K* updates to *v* the value of *K*(*p*/ *f*) of the existing field *f* , while rule (EXTEND) is used when the agent *<sup>A</sup>* <sup>=</sup> *update*(*p*/*f*, *<sup>v</sup>*) then *<sup>P</sup>* - *K* expands (at the end of) an existing path *p* with a field *f* such that *K*(*p*/ *f*) = *v*; afterwards the agent *A* executes process *P*.

Rule (CALL) is used when an agent *<sup>A</sup>* = *id*(*v*) - *K* is ready to unfold the process *id*(*v*) into {*v*/*u*}*Pid*. Rule (PAR) is used to put together the behaviour of smaller subnetworks. while rule (EQUIV) is used to apply the structures congruence over networks.

In Table 3 are presented the rules for describing time passing, while the knowledge of

the involved agents remains unchanged. The relation *N <sup>t</sup> N* indicates the transformation of a network *N* into a network *N* after *t* units of time.


**Table 3.** Operational Semantics of knowTIMO : Time Passing.

In rule (STOP), *l*[[**0**]] denotes a network without agents; the passing of time does not affect such a network. Rules (DPUT), (DGET) and (DMOVE) are used to decrease the timers of actions, while rules (DPAR) is used to put together the behaviour of composed networks. In rule (DPAR), *N*<sup>1</sup> | *N*<sup>2</sup> −→ denotes a network *N*<sup>1</sup> | *N*<sup>2</sup> that cannot execute any action; this is possible because the use of negative premises in our operational semantics does not lead to inconsistencies.

Given a finite multiset of actions Λ = {*λ*1, ... , *λk*} and a timeout *t*, a derivation *<sup>N</sup>* <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* captures a complete computational step of the form:

$$N \xrightarrow{\lambda\_1} N\_1 \dots N\_{k-1} \xrightarrow{\lambda\_k} N\_k \xrightarrow{t} N' \dots$$

The fact that a knowTIMO network *N* is able to perform zero or more actions steps and a time step in order to reach a network *N* is denoted by *N* =⇒<sup>∗</sup> *N* . Notice that the consumed actions and elapsed time are not recorded. By *<sup>N</sup> <sup>λ</sup>* <sup>=</sup>⇒∗*N* we denote the fact that there exist networks *N*<sup>1</sup> and *N*<sup>2</sup> such that *N* =⇒<sup>∗</sup> *N*<sup>1</sup> *<sup>λ</sup>* −→ *<sup>N</sup>*<sup>2</sup> <sup>=</sup>⇒<sup>∗</sup> *<sup>N</sup>* ; in this way we emphasize only the consumed action *λ* out of all consumed actions.

In our setting, at most one time passing rule can be applied for any arbitrary given process. This is the reason why, by inverting a rule, we can describe how the time passes in the subprocesses of a process. This result is useful when reasoning by induction on the structure of processes for which time passes.

**Proposition 1.** *Assume N <sup>t</sup> N . Then exactly one of the following holds:*


**Proof.** Straightforward, by observing that the time passing rules in Table 3 can be deterministically inverted; namely, each network of Table 1 performing a time step can use at most one rule of Table 3.

The following theorem claims that time passing does not introduce nondeterminism in the evolution of a network.

**Theorem 1.** *The next two statements hold for any three networks N, N and N:*


**Proof.** 1. We proceed by induction on the structure of *N*.


*N*<sup>2</sup> = *N* <sup>2</sup>, respectively. Thus *N* <sup>1</sup> = *N* <sup>1</sup> | *N* <sup>2</sup> = *N*<sup>1</sup> | *N*2, meaning that *N* = *N* (as desired).

	- Case *N* = *l*[[**0**]]. Since *N <sup>t</sup> N* and *N <sup>t</sup> N*, by using Proposition 1, it holds that *N* = *l*[[**0**]] and *N* = *l*[[**0**]], respectively, meaning that *N* = *N* (as desired).
	- Case *N* = *l*[[*a*Δ*<sup>t</sup>* ! *<sup>v</sup>* then *<sup>P</sup>* else *<sup>Q</sup>* - *K*]]. Since *N <sup>t</sup> N* and *N <sup>t</sup> N*, by using Proposition 1, it holds that *N* = *l*[[*a*Δ*<sup>t</sup>* −*t* ! *<sup>v</sup>* then *<sup>P</sup>* else *<sup>Q</sup>* - *K*]] and *N* = *l*[[*a*Δ*<sup>t</sup>* −*t* ! *<sup>v</sup>* then *<sup>P</sup>* else *<sup>Q</sup>* - *K*]], respectively, meaning that *N* = *N* (as desired).
	- Case *N* = *l*[[*a*Δ*<sup>t</sup>* ?(*u*) then *<sup>P</sup>* else *<sup>Q</sup>* - *K*]]. Since *N <sup>t</sup> N* and *N <sup>t</sup> N*, by using Proposition 1, it holds that *N* = *l*[[*a*Δ*<sup>t</sup>* −*t* ?(*u*) then *<sup>P</sup>* else *<sup>Q</sup>* - *K*]] and *N* = *l*[[*a*Δ*<sup>t</sup>* −*t* ?(*u*) then *<sup>P</sup>* else *<sup>Q</sup>* - *K*]], respectively, meaning that *N* = *N* (as desired).
	- Case *<sup>N</sup>* <sup>=</sup> *<sup>l</sup>*[[go*<sup>t</sup> l* then *<sup>P</sup>* - *K*]]. Since *N <sup>t</sup> N* and *N <sup>t</sup> N*, by using Proposition 1, it holds that *<sup>N</sup>* <sup>=</sup> *<sup>l</sup>*[[go*<sup>t</sup>* <sup>−</sup>*<sup>t</sup> l* then *<sup>P</sup>* - *<sup>K</sup>*]] and *<sup>N</sup>* <sup>=</sup> *<sup>l</sup>*[[go*<sup>t</sup>* <sup>−</sup>*<sup>t</sup> l* then *<sup>P</sup>* - *K*]], respectively, meaning that *N* = *N* (as desired).
	- Case *<sup>N</sup>* <sup>=</sup> *<sup>N</sup>*<sup>1</sup> <sup>|</sup> *<sup>N</sup>*2. Since *<sup>N</sup> <sup>t</sup> <sup>N</sup>* , by using Proposition 1, it holds that there exist *N* <sup>1</sup> and *N* <sup>2</sup> such that *N* = *N* <sup>1</sup> | *N* <sup>2</sup>, together with *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> and *N*<sup>2</sup> *<sup>t</sup> N* 2. Similarly, since *N <sup>t</sup> N*, by using Proposition 1, it holds that there exist *N* 1 and *N* <sup>2</sup> such that *N* = *N* <sup>1</sup> | *N* <sup>2</sup> , together with *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> and *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> . By induction, *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> and *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> imply that *N* <sup>1</sup> = *N* <sup>1</sup> , while *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> and *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> imply that *N* <sup>2</sup> = *N* <sup>2</sup> . Thus, *N* <sup>1</sup> = *N* <sup>1</sup> | *N* <sup>2</sup> = *N* <sup>1</sup> | *N* <sup>2</sup> , meaning that *N* = *N* (as desired).

The following theorem claims that whenever only the rules of Table 3 can be applied for two time steps of lengths *t* and *t* , then the rules can be applied also for a time step of length *t* + *t* .

**Theorem 2.** *If N <sup>t</sup> <sup>N</sup> <sup>t</sup> N , then N <sup>t</sup>*+*<sup>t</sup> N .*

**Proof.** We proceed by induction on the structure of *N*.


Regarding the knowledge of an agent, we have the following result showing that any given agent can be obtained starting from an agent without any knowledge.

**Proposition 2.** *If N* =*l*[[*P* -*K*]] *with K* = ∅*, then there exists N* =*l*[[*P* -*K* ]] *with K* = ∅ *such that N* =⇒<sup>∗</sup> *N.*

**Proof.** We proceed by induction on the structure of *K*.

	- *<sup>N</sup>* =*l*[[*P* -*K* ]] with *<sup>K</sup>* <sup>=</sup> <sup>∅</sup>, it holds that *<sup>N</sup> createf* @*<sup>l</sup>* −−−−−→ *N* =⇒<sup>∗</sup> *N* (as desired).

The next result is a consequence of the previous one; it claims that any given network in knowTIMO can be obtained starting from a network containing only agents without knowledge.

**Theorem 3.** *If N* =*l*1[[*P* 11 -*K* <sup>11</sup> || ... || *P* 1*n* -*K* <sup>1</sup>*n*]] | ... | *lm*[[*P m*1 -*K <sup>m</sup>*<sup>1</sup> || ... || *P mn* -*K mn*]]*, then there exists N* =*l*1[[*P* 11 -*K* <sup>11</sup> || ... || *P* 1*n* -*K* <sup>1</sup>*n*]] | ... | *lm*[[*P m*1 -*K <sup>m</sup>*<sup>1</sup> || ... || *P mn* -*K mn*]] *with K ij* = ∅ *(*1 ≤ *i* ≤ *m,* 1 ≤ *j* ≤ *n) such that N* =⇒<sup>∗</sup> *N.*

The following example illustrates how agents communicate and make use of their knowledge.

**Example 1.** *To illustrate how multi-agent systems can be described in* knowTIMO*, we adapt the travel agency example from [3], where all the involved agents have a cyclic behaviour. Consider a travel agency with seven offices (one central and six locals) and five employees (two executives and three travel agents). As the agency is understaffed and all local offices need to be used from time to time, the executives meet with the agents daily at the central office in order to assign them local* *offices where they sell travel packages by interacting with potential customers. We consider two customers that are willing to visit the local offices closer to their homes. In what follows we show how each of the involved agents can be described by using the* knowTIMO *syntax.*

*Each day, agent* A1 *executes the action* go<sup>10</sup> office *in order to move after* <sup>10</sup> *time units from location* homeA1 *to the central* office*. After reaching the central office, in order to find out at which local office will work for the rest of the day, it executes the action b*<sup>Δ</sup>5?(newloc) *to try to communicate with any of the executives in the next* 5 *time units. The location variable* newloc *is needed to model a dynamic evolution based on the local office assigned by an available executive. After successfully communicating with an executive, the agent A*<sup>1</sup> *moves to location officei after* 5 *time units in order to communicate with potential customers using channel ai in order to sell a travel package towards location* destA1 *at the cost of* 100 *monetary units. After each working day, the agent returns home by executing the action* go<sup>3</sup> home*A*1*. The agents* A2 *and* A3 *behave similarly to* A1*, except that they begin and end their days at different locations, work locally at different offices and the travel packages they advertise are different.*

*Formally, the travel agents are described by the recursive processes* AX(homeAX) -*K*AX*:*

AX(homeAX) = go<sup>10</sup> office then AX(office)

AX(office) = *b*<sup>Δ</sup>5?(newloc)

then (go<sup>5</sup> newloc then AX(newloc))

else AX(office)

AX(officei) = *update*(/*work*, office*i*)

$$\begin{array}{l} \mathsf{then} \ a\_i^{\mathsf{A}9} ! \langle \mathsf{K}\_{\mathsf{A}\mathsf{X}}(\langle \mathsf{w} \mathsf{ork}/\mathsf{dest}) , \mathsf{K}\_{\mathsf{A}\mathsf{X}}(\langle \mathsf{w} \mathsf{ork}/\mathsf{price}) \rangle \\ \mathsf{then} \ \mathsf{we} \stackrel{\scriptstyle \mathsf{A}}{\rightarrow} \ \mathsf{then} \ \mathsf{w} \stackrel{\scriptstyle \mathsf{A}}{\rightarrow} \ \mathsf{then} \ \mathsf{A} \stackrel{\scriptstyle \mathsf{A}}{\rightarrow} \end{array}$$

then go<sup>3</sup> homeAX then AX(homeAX)

$$\begin{array}{l} \text{else go}^3 \text{ home}\_{\mathsf{AX}} \text{ then } \mathsf{A}\_{\mathsf{X}}(\text{home}\_{\mathsf{AX}})\\ \text{/} \text{dot} \mid \mathsf{A}\_{\mathsf{act}} \dots \mid \mathsf{virica} \mid \mathsf{r} \boldsymbol{\alpha} \boldsymbol{\alpha} \mid \mathsf{r} \boldsymbol{\vee} \boldsymbol{\vee} \boldsymbol{\vee} \boldsymbol{\vee} \end{array}$$

*K*AX = *work* | office; *dest* | *destAX price* | *100* · *X.*

*The identifiers AX (*1 ≤ *X* ≤ 3*) are uniquely assigned to the three travel agents, and* office*<sup>i</sup> (*1 ≤ *i* ≤ 6*) indicate the six local offices.*

*Given the knowledge KAX defined above, we exemplify how it can be used for some queries:*


*Executives* E1 *and* E2 *are placed in the central* office*, being available for communication on channel b for* 5 *time minutes. In this way, they can assign to the travel agents (in a cyclic manner) the locations* office1*,* office3*,* office5*, and the locations* office2*,* office4*,* office6*, respectively. Formally, the executives are described by* EX(officeY) -*K*EX*:*

EX(officeY) = *update*(/*work*, office*Y*) then *<sup>b</sup>*<sup>Δ</sup>5! *KEX*(/*work*) then EX(officeY+2) else EX(officeY)

*K*EX = ∅*.*

*The identifiers EX (with* 1 ≤ *X* ≤ 2*) are uniquely assigned to the two executives, while* office*<sup>Y</sup> (with Y* ∈ {*X*, *X* + 2, *X* + 4}*) indicate the local offices that each executive EX can assign to travel agents. Defining the index of the local offices in this way ensures that the executives assign the existing local offices in a cyclic way.*

*The client* C1 *initially resides at location* homeC1*; being interested in a travel package, client* C1 *is willing to visit the local offices closer to his location, namely* office1*,* office2*, and* office3*. For each of these three local offices, the visit has two possible outcomes: if client* C1 *interacts with an agent then it will acquire a travel offer, while if the highoffice is closed then client* C1 *moves to the next local office from its itinerary. Once its journey through the three local offices ends, client* C1 *returns home whenever was unable to collect any travel offer, while goes at the destination for which he has to pay the lowest amount whenever got at least one offer. After the holiday period ends, client* C1 *returns home, where can restart the process of searching for a holiday destination. Client* C2 *behaves in a similar manner as client* C1 *does, except looking for the most expensive*

*travel package while visiting the local offices* office4*,* office5 *and* office6*. Formally, the clients are described by* CX(homeCX) -*K*CX*:*

CX(homeCX) = go<sup>13</sup> officeZ+<sup>1</sup> then CX(officeZ+1) CX(officeZ+1) = *a*Δ<sup>4</sup> *<sup>Z</sup>*+1?(destCX,1, costCX,1) then *update*(/*agency*[*testZ*+*1*]/*dest*, *destCX*,*1*) then *update*(/*agency*[*testZ*+*1*]/*price*, *costCX*,*1*) then go<sup>2</sup> officeZ+<sup>2</sup> then CX(officeZ+2) else *update*(/*agency*[*testZ*+*1*]/*dest*, *<sup>ε</sup>* ) then *update*(/*agency*[*testZ*+*1*]/*price*, *<sup>ε</sup>* ) then go<sup>2</sup> officeZ+<sup>2</sup> then CX(officeZ+2) *, where testZ*+*<sup>1</sup>* = (*KCX*(/*agency*) = office*Z*+*1*) CX(officeZ+2) = *a*Δ<sup>4</sup> *<sup>Z</sup>*+2?(destCX,2, costCX,2) then *update*(/*agency*[*testZ*+*2*]/*dest*, *destCX*,*2*) then *update*(/*agency*[*testZ*+*2*]/*price*, *costCX*,*2*) then go<sup>3</sup> officeZ+<sup>3</sup> then CX(officeZ+3) else *update*(/*agency*[*testZ*+*2*]/*dest*, *<sup>ε</sup>* ) then *update*(/*agency*[*testZ*+*2*]/*price*, *<sup>ε</sup>* ) then go<sup>2</sup> officeZ+<sup>3</sup> then CX(officeZ+3) *, where testZ*+*<sup>2</sup>* = (*KCX*(/*agency*) = office*Z*+*2*) CX(officeZ+3) = *a* Δ4 *<sup>Z</sup>*+3?(destCX,3, costCX,3) then *update*(/*agency*[*testZ*+*3*]/*dest*, *destCX*,*3*) then *update*(/*agency*[*testZ*+*3*]/*price*, *costCX*,*3*) then CX(nextCX) else *update*(/*agency*[*testZ*+*3*]/*dest*, *<sup>ε</sup>* ) then *update*(/*agency*[*testZ*+*3*]/*price*, *<sup>ε</sup>* ) then CX(nextCX) *, where testZ*+*<sup>3</sup>* = (*KCX*(/*agency*) = office*Z*+*3*) CX(nextCX) = *i f* testX then (go<sup>5</sup> nextCX then CX(nextCX)) else (go<sup>5</sup> homeCX then CX(homeCX)) CX(destCX,i) = go<sup>5</sup> destCX then CX(homeCX) *K*CX = *agency* | officeZ+1; *dest* | *ε price* | *ε agency* | officeZ+2; *dest* | *ε price* | *ε agency* | officeZ+3; *dest* | *ε price* | *ε .*

*The identifiers CX (with* 1 ≤ *X* ≤ 2*) are uniquely assigned to the two clients, the identifiers* destCX,i *uniquely identify the possible destinations the clients CX can visit, while Z* = 3 ∗ (*X* − 1) *(with X* ∈ {1, 2}*) are used to identify the local offices for each of the clients. The tests used above are:*

$$\begin{aligned} \text{testX} &= - (\text{K}\_{\text{CX}} (/\text{ageancy} / \text{price}) = \varepsilon \text{ }), \\ \text{test} &= \begin{cases} \text{K}\_{\text{CX}} (/\text{ageancy} [\text{test}\_{\text{min}}] / \text{des}\_{\text{CX},i}) \\ \text{if } \text{X} = 1 \text{ and } \text{K}\_{\text{CX}} (/\text{ageancy} / \text{price}) = \min\_{j \in \{1, 2, 3\}} \text{cost}\_{\text{CX},j} \in \mathbb{N}; \\ \text{K}\_{\text{CX}} (/\text{ageancy} [\text{test}\_{\text{max}}] / \text{des}\_{\text{CX},i}) \\ \text{if } \text{X} = 2 \text{ and } \text{K}\_{\text{CX}} (/\text{ageancy} / \text{price}) = \max\_{j \in \{1, 2, 3\}} \text{cost}\_{\text{CX},j} \in \mathbb{N}; \\ \text{home}\_{\text{CX}} &\text{otherwise}. \end{cases} \end{aligned}$$

*The initial state of the system given as the* knowTIMO *network N is:*

homeA1[[A1(homeA1) - *<sup>K</sup>*A1]] | homeA2[[A2(homeA2) -*K*A2]]


*where N stands for:*

office1[[**0**]] | office2[[**0**]] | office3[[**0**]] | office4[[**0**]] | office5[[**0**]] | office6[[**0**]] | dest1[[**0**]] | dest2[[**0**]] | dest3[[**0**]]*.*

*In what follows we show how some of the rules of Tables 2 and 3 are applied such that network N evolves. Since the network N is defined by means of recursive processes, in order to execute their actions we need to use the rules* (CALL) *and* (PAR) *for unfolding, namely*

{*call*,*call*,*call*,*call*,*call*,*call*,*call*} −−−−−−−−−−−−−−−→ (CALL)*,* (PAR) homeA1[[(go<sup>10</sup> office then A1(office) - KA1]] homeA2[[(go<sup>10</sup> office then A2(office) - KA2]] homeA3[[(go<sup>10</sup> office then A3(office) - KA3]] | office[[*update*(/*work*, office*1*) then *<sup>b</sup>*<sup>Δ</sup>5! *KE*1(/*work*) then E1(office3) else E1(office1) -*K*E1 || *update*(/*work*, office*2*) then *<sup>b</sup>*<sup>Δ</sup>5! *KE*2(/*work*) then E2(office4) else E2(office2) -*K*E2]] <sup>|</sup> homeC1[[go<sup>13</sup> office1 then C1(office1)]] <sup>|</sup> homeC2[[go<sup>13</sup> office4 then C2(office4)]] | *N .*

*The next step is represented by the two updates performed by the executives; thus, the rules* (EXTEND) *and* (PAR) *are applied several times. Since the existing knowledge of the two executives is currently* ∅*, this means that these updates extend in fact their knowledge.*

{*upd*,*upd*} −−−−−→ (EXTEND)*,* (PAR) homeA1[[(go<sup>10</sup> office then A1(office) - KA1]] homeA2[[(go<sup>10</sup> office then A2(office) - KA2]] homeA3[[(go<sup>10</sup> office then A3(office) - KA3]] <sup>|</sup> office[[ *<sup>b</sup>*<sup>Δ</sup>5! *KE*1(/*work*) then E1(office3) else E1(office1) *work* | office*1*; ∅ || *<sup>b</sup>*<sup>Δ</sup>5! *KE*2(/*work*) then E2(office4) else E2(office2) *work* | office*2*; ∅]] <sup>|</sup> homeC1[[go<sup>13</sup> office1 then C1(office1)]] <sup>|</sup> homeC2[[go<sup>13</sup> office4 then C2(office4)]] | *N .*

*Since the rules of Table 2 are not applicable to the above network, then only time passing can be applied by using the rules of Table 3. The rules* (DMOVE)*,* (DGET) *and* (DPAR) *can be applied for t* = 5*, namely the maximum time units that can be performed.*

<sup>5</sup> (DMOVE)*,* (DGET)*,* (DPAR)

homeA1[[(go<sup>5</sup> office then A1(office) - KA1]] homeA2[[(go<sup>5</sup> office then A2(office) - KA2]] homeA3[[(go<sup>5</sup> office then A3(office) - KA3]] <sup>|</sup> office[[ *<sup>b</sup>*<sup>Δ</sup>0! *KE*1(/*work*) then E1(office3) else E1(office1) *work* | office*1*; ∅ || *<sup>b</sup>*<sup>Δ</sup>0! *KE*2(/*work*) then E2(office4) else E2(office2) *work* | office*2*; ∅]] <sup>|</sup> homeC1[[go<sup>8</sup> office1 then C1(office1)]] <sup>|</sup> homeC2[[go<sup>8</sup> office4 then C2(office4)]] | *N .*

$$^{81}$$

*Since after* 5 *time units of the evolution there are no agents to communicate with the executives on channel b, then the rules* (PUT0) *and* (PAR) *are applied such that the* else *branches of the two executives are chosen to be executed next.*

{*b*! <sup>Δ</sup>0@*office*, *b*! <sup>Δ</sup>0@*office*} −−−−−−−−−−−−−→ (PUT0)*,* (PAR) homeA1[[(go<sup>5</sup> office then A1(office) - KA1]] homeA2[[(go<sup>5</sup> office then A2(office) - KA2]] homeA3[[(go<sup>5</sup> office then A3(office) - KA3]] | office[[ E1(office1) *work* | office*1*; ∅ || E2(office2) *work* | office*2*; ∅]] <sup>|</sup> homeC1[[go<sup>8</sup> office1 then C1(office1)]] <sup>|</sup> homeC2[[go<sup>8</sup> office4 then C2(office4)]] | *N . Note that the evolution was deterministic during the first* 5 *time units. However, since there*

*are two executives and three travel agents into the system, the communication on channel b will take place in a nondeterministic manner, and thus there exists several possible future evolutions of the system.*

#### **3. Behavioural Equivalences in knowTIMO**

In what follows, we define and study bisimulations for multi-agent systems that consider knowledge dynamics as well as explicit time constraints for communication and migration. Since a bisimilarity is the union of all bisimulations of the same type, in order to demonstrate that two knowTIMO networks *N*<sup>1</sup> and *N*<sup>2</sup> are bisimilar it is enough to discover a bisimulation relation containing the pair (*N*1, *N*2). This standard bisimulation proof method is interesting for the following reasons:


#### *3.1. Strong Timed Equivalences*

Inspired by the approach taken in [4], we extend the standard notion of strong bisimilarity by allowing also timed transitions to be taken into account.

#### **Definition 1** (Strong timed bisimulation)**.**

*Let* R⊆N ×N *be a symmetric binary relation over* knowTIMO *networks.*

*1.* R *is a* strong timed bisimulation *if*


Definition 1 treats in a similar manner the timed transitions and the labelled transitions, and so the bisimilarity notion is similar to the bisimilarity notion originally given for labelled transition systems. We can prove that the relation ∼ is the largest strong timed bisimulation, and also an equivalence relation.

#### **Proposition 3.**


#### **Proof.**

	- (a) The identity relation *Id*<sup>R</sup> is a strong timed bisimulation.
		- i. Assume (*N*, *<sup>N</sup>*) <sup>∈</sup> *Id*R. Consider *<sup>N</sup> <sup>λ</sup>* −→ *N* ; then (*N* , *N* ) ∈ *Id*<sup>R</sup> .
		- ii. Assume (*N*, *<sup>N</sup>*) <sup>∈</sup> *Id*R. Consider *<sup>N</sup> <sup>t</sup> <sup>N</sup>* ; then (*N* , *N* ) ∈ *Id*<sup>R</sup> .
	- (b) The inverse of a strong timed bisimulation is a strong timed bisimulation.
		- i. Assume (*N*1, *<sup>N</sup>*2)∈R<sup>−</sup>1, namely (*N*2, *<sup>N</sup>*1)∈R. Consider *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→*N* <sup>2</sup>; then for some *N* <sup>1</sup> we have *N*<sup>1</sup> *λ* −→*N* <sup>1</sup> and (*N* <sup>2</sup>, *N* <sup>1</sup>)∈R, namely (*N* <sup>1</sup>, *N* <sup>2</sup>)∈R<sup>−</sup>1. By similar reasoning, if *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup> then we can find *N* <sup>2</sup> such that *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* 2 and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R−<sup>1</sup> .
		- ii. Assume (*N*1, *<sup>N</sup>*2)∈R<sup>−</sup>1, namely (*N*2, *<sup>N</sup>*1)∈R. Consider *<sup>N</sup>*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup>; then for some *N* <sup>1</sup> we have *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> and (*N* <sup>2</sup>, *N* <sup>1</sup>)∈R , namely (*N* <sup>1</sup>, *N* <sup>2</sup>)∈R<sup>−</sup>1. By similar reasoning, if *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> then we can find *N* <sup>2</sup> such that *N*<sup>2</sup> *<sup>t</sup> N* 2 and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R−<sup>1</sup> .
	- (c) The composition of strong timed bisimulations is a strong timed bisimulation.
		- i. Assume (*N*1, *N*2) ∈ R1R2. Then for some *N* we have (*N*1, *N*) ∈ R<sup>1</sup> and (*N*, *N*2) ∈ R2. Consider *N*<sup>1</sup> *λ* −→*N* <sup>1</sup>; then for some *N* , since (*N*1, *N*)∈R1, we have *N <sup>λ</sup>* −→ *N* and (*N* <sup>1</sup>, *N* ) ∈ R1. Also, since (*N*, *N*2) ∈ R<sup>2</sup> we have for some *N* <sup>2</sup> that *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> and (*N* , *N* <sup>2</sup>) ∈ R2. Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R1R2. By similar reasoning, if *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *λ* −→ *N* 1 and (*N* , *N*
		- <sup>2</sup>) ∈ R<sup>2</sup> . ii. Assume (*N*1, *<sup>N</sup>*2) ∈ R1R2. Then for some *<sup>N</sup>* we have (*N*1, *<sup>N</sup>*) ∈ R<sup>1</sup> and (*N*, *N*2) ∈ R2. Consider *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup>; then for some *N* , since (*N*1, *<sup>N</sup>*) ∈ R1, we have *<sup>N</sup> <sup>t</sup> <sup>N</sup>* and (*N* <sup>1</sup>, *N* ) ∈ R1. Also, since (*N*, *N*2) ∈ R<sup>2</sup> we have for some *N* <sup>2</sup> that *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> and (*N* , *N* <sup>2</sup>) ∈ R2. Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R1R2. By similar reasoning, if *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> and (*N* , *N* <sup>2</sup>) ∈ R<sup>2</sup> .
	- (d) The union of strong timed bisimulations is a strong timed bisimulation.
		- i. Assume (*N*1, *<sup>N</sup>*2) ∈ *<sup>i</sup>*<sup>∈</sup> *<sup>I</sup>* R*i*. Then for some *<sup>i</sup>* ∈ *<sup>I</sup>* we have (*N*1, *<sup>N</sup>*2) ∈ R*i*. Consider *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup>; then for some *N* <sup>2</sup>, since (*N*1, *N*2) ∈ R*i*, we have *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*i*. Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. By similar reasoning, if *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*i*, namely (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈
		- *<sup>i</sup>*∈*<sup>I</sup>* <sup>R</sup>*i*. ii. Assume (*N*1, *<sup>N</sup>*2) <sup>∈</sup> *<sup>i</sup>*∈*<sup>I</sup>* R*i*. Then for some *<sup>i</sup>* ∈ *<sup>I</sup>* we have (*N*1, *<sup>N</sup>*2) ∈ R*i*. Consider *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup>; then for some *N* <sup>2</sup>, since (*N*1, *N*2) ∈ R*i*, we have *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*i*. Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. By similar reasoning, if *N*<sup>2</sup> *<sup>t</sup> N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*i*, namely (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*.
	- (a) Reflexivity: For any network *N*, *N* ∼ *N* results from the fact that the identity relation is a strong timed bisimulation.
	- (b) Symmetry: If *N* ∼ *N* , then (*N*, *N* ) ∈ R for some strong timed bisimulation R. Hence (*N* , *<sup>N</sup>*) ∈ R<sup>−</sup>1, and so *<sup>N</sup>* ∼ *<sup>N</sup>* because the inverse relation is a strong timed bisimulation.
	- (c) Transitivity: If *N* ∼ *N* and *N* ∼ *N* then (*N*, *N* ) ∈ R<sup>1</sup> and (*N* , *N*) ∈ R<sup>2</sup> for some strong timed bisimulations R<sup>1</sup> and R2. Thus, (*N*, *N*) ∈ R1R2, and so *N* ∼ *N* due to the fact that the composition relation is a strong timed bisimulation.

The next result claims that the strong timed equivalence ∼ among processes is preserved even if the local knowledge of the agents is expanded. This is consistent with the fact that the processes affect the same portion of their knowledge. To simplify the presentation, in what follows we assume the notations | *n <sup>i</sup>*=<sup>1</sup> *Ni* = *N*<sup>1</sup> | ... | *Nn* and ||*<sup>n</sup> <sup>i</sup>*=<sup>1</sup> *Ai* = *A*<sup>1</sup> || ... || *An*.

**Proposition 4.** *If K ij* ⊆ *K ij for* 1 ≤ *i* ≤ *n,* 1 ≤ *j* ≤ *m, then* | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] ∼ |*<sup>n</sup> <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]]*.*

### **Proof.** We show that S is a strong timed bisimulation, where:

S ={(| *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]] , | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]]) : *K ij* ⊆*K ij*, 1≤*i*≤*n*, 1≤ *j*≤*m*}. The proof is by induction on the last performed step:

	- **–** Consider *<sup>λ</sup>* <sup>=</sup> *<sup>a</sup>*!?@*l*1. Then there exists *<sup>P</sup>*<sup>11</sup> <sup>=</sup> *<sup>a</sup>*Δ*t*<sup>1</sup> ! *<sup>v</sup>* then *<sup>P</sup>* <sup>11</sup> else *<sup>P</sup>* <sup>11</sup> and *<sup>P</sup>*<sup>12</sup> <sup>=</sup> *<sup>a</sup>*Δ*t*<sup>2</sup> ?(*u*) then *<sup>P</sup>* <sup>12</sup> else *<sup>P</sup>* <sup>12</sup> such that *<sup>l</sup>*1[[*P*<sup>11</sup> - *K* <sup>11</sup> || *P*<sup>12</sup> - *K* <sup>12</sup> ||*<sup>m</sup> <sup>j</sup>*=<sup>3</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>a</sup>*!?@*l*<sup>1</sup> −−−→ *<sup>l</sup>*1[[*P* 11 - *K* <sup>11</sup> || *P* 12 - *K* <sup>12</sup> ||*<sup>m</sup> <sup>j</sup>*=<sup>3</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] = *N* . Then there exists *N* = [[*P* 11 - *K* <sup>11</sup> || *P* 12 - *K* 12 ||*m <sup>j</sup>*=<sup>3</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] such that | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>a</sup>*!?@*l*<sup>1</sup> −−−→ *<sup>N</sup>*. Since *K ij* ⊆ *K ij*, 1 ≤ *i* ≤ *n*, 1 ≤ *j* ≤ *m*, clearly (*N* , *N*) ∈ S.
	- **–** Consider *λ* = *a*! <sup>Δ</sup>0@*l*1. Then there exists *<sup>P</sup>*<sup>11</sup> <sup>=</sup> *<sup>a</sup>*<sup>Δ</sup>0! *<sup>v</sup>* then *<sup>P</sup>* <sup>11</sup> else *<sup>P</sup>* <sup>11</sup> such that *<sup>l</sup>*1[[*P*<sup>11</sup> - *K* <sup>11</sup> ||*<sup>m</sup> <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>a</sup>*! <sup>Δ</sup>0@*l*<sup>1</sup> −−−−→ *<sup>l</sup>*1[[*P* 11 - *K* 11 ||*m <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] = *N* . Then there exists *N* = *l*1[[*P* 11 - *K* 11 ||*m <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* -*K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]] such that | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]]) *<sup>a</sup>*! <sup>Δ</sup>0@*l*<sup>1</sup> −−−−→*N*. Since *K ij* ⊆ *K ij*, 1 ≤ *i* ≤ *n*, 1 ≤ *j* ≤ *m*, clearly (*N* , *N*) ∈ S.
	- **–** Consider *<sup>λ</sup>* <sup>=</sup> *<sup>a</sup>*?<sup>Δ</sup>0@*l*1. Then there exists *<sup>P</sup>*<sup>11</sup> <sup>=</sup> *<sup>a</sup>*<sup>Δ</sup>0?(*u*) then *<sup>P</sup>* <sup>11</sup> else *<sup>P</sup>* <sup>11</sup> such that *<sup>l</sup>*1[[*P*11- *K* <sup>11</sup> ||*<sup>m</sup> <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>a</sup>*?<sup>Δ</sup>0@*l*<sup>1</sup> −−−−→ *<sup>l</sup>*1[[*P* 11 - *K* 11 ||*m <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] = *N* . Then there exists *N* = *l*1[[*P* 11 - *K* 11 ||*m <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* -*K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]] such that | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]]) *<sup>a</sup>*?<sup>Δ</sup>0@*l*<sup>1</sup> −−−−→*N*. Since *K ij* ⊆ *K ij*, 1 ≤ *i* ≤ *n*, 1 ≤ *j* ≤ *m*, clearly (*N* , *N*) ∈ S.
	- **–** Consider *λ* = *l*<sup>1</sup> *<sup>l</sup>*2. Then there exists *<sup>P</sup>*<sup>11</sup> <sup>=</sup> go<sup>0</sup> *<sup>l</sup>*<sup>2</sup> then *<sup>P</sup>* <sup>11</sup> such that *<sup>l</sup>*1[[*P*11- *K* 11 ||*m <sup>j</sup>*=<sup>2</sup> *P*1*j*- *K* 1*j* ]] | *n <sup>i</sup>*=<sup>2</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>l</sup>*1*<sup>l</sup>*<sup>2</sup> −−→ *<sup>l</sup>*1[[||*<sup>m</sup> <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *l*2[[*P* 11 - *K* 11 ||*m <sup>j</sup>*=<sup>1</sup> *P*2*j*- *K* 2*j* ]] | *n <sup>i</sup>*=<sup>3</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] = *N* . Then there exists *<sup>N</sup>* = *<sup>l</sup>*1[[||*<sup>m</sup> <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]] | *l*2[[*P* 11 - *K* <sup>11</sup> ||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *P*2*j*- *K* 2*j* ]] | *n <sup>i</sup>*=<sup>3</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] such that



The symmetric cases follow by similar arguments.

The following result shows that strong timed bisimulation is preserved even after complete computational steps of two knowTIMO networks.

**Proposition 5.** *Let N*1, *N*<sup>2</sup> *be two* knowTIMO *networks. If N*<sup>1</sup> ∼ *N*<sup>2</sup> *and N*<sup>1</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* 1*, then there exists N* <sup>2</sup> ∈ N *such that N*<sup>2</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>2</sup> *and N* <sup>1</sup> ∼ *N* 2*.*

**Proof.** Assuming that the finite multiset of actions Λ contains the labels {*λ*1, ... , *λk*}, then the complete computational step *N*<sup>1</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>1</sup> can be detailed as *N*<sup>1</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>1</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>1</sup> *λk* −→ *Nk* 1 *<sup>t</sup> N* <sup>1</sup>. Since *N*<sup>1</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>1</sup> and *<sup>N</sup>*<sup>1</sup> ∼ *<sup>N</sup>*2, then according to Definition <sup>1</sup> there exists *<sup>N</sup>*<sup>1</sup> 2 ∈ N such that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>2</sup> and *<sup>N</sup>*<sup>1</sup> <sup>1</sup> ∼ *<sup>N</sup>*<sup>1</sup> <sup>2</sup> . The same reasoning can be applied for another *k* steps, meaning that there exist *N*<sup>2</sup> <sup>2</sup> , ... , *<sup>N</sup><sup>k</sup>* <sup>2</sup> , *N* <sup>2</sup> ∈ N such that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>2</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>2</sup> *<sup>λ</sup><sup>k</sup>* −→ *<sup>N</sup><sup>k</sup>* 2 *<sup>t</sup> N* 2 and *N* <sup>1</sup> ∼ *N* <sup>2</sup>. By the definition of a complete computational step, it holds that *N*<sup>2</sup> *λ*1 −→

*N*<sup>1</sup> <sup>2</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>2</sup> *<sup>λ</sup><sup>k</sup>* −→ *<sup>N</sup><sup>k</sup>* 2 *<sup>t</sup> N* <sup>2</sup> can be written as *N*<sup>2</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>2</sup>. Thus, we obtained that there exists *N* <sup>2</sup> ∈ N such that *N*<sup>2</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>2</sup> and *N* <sup>1</sup> ∼ *N* <sup>2</sup> (as desired).

The next example illustrates that the relation ∼ is able to distinguish between agents with different knowledge if *update* operations are performed.

**Example 2.** *Consider that client C*<sup>2</sup> *is at location* office4*, ready to communicate on channel a*4*. To simplify the presentation, we take only a simplified definition of C*<sup>2</sup> *as follows:*

C <sup>2</sup>(office4) = *<sup>a</sup>*Δ<sup>4</sup> <sup>4</sup> ?(destC2,1, costC2,1) then *update*(/*agency*[*test4*]/*dest*, *destC2*,*1*) else *update*(/*agency*[*test4*]/*dest*, *<sup>ε</sup>* )*.*

*Consider the following three networks in* knowTIMO *:*

*N*<sup>1</sup> = office4[[C <sup>2</sup>(office4) - *K*C2]]*, N* <sup>1</sup> = office4[[C <sup>2</sup>(office4) - *K* C2]]*, N* <sup>1</sup> = office4[[C <sup>2</sup>(office4) - *K* C2]]*,*

*where the knowledge of the agents is defined as:*

*K*C2 = *agency* | office4; *dest* | *ε price* | *ε , K* C2 = *agency* | office5; *dest* | *ε price* | *ε , K* C2 = ∅*.*

*According to Definition 1, it holds that N* <sup>1</sup> ∼ *N* <sup>1</sup> *, while N*<sup>1</sup> ∼ *N* <sup>1</sup> *and N*<sup>1</sup> ∼ *N* <sup>1</sup> *. This is due to the fact that while all three networks are able to perform a time step of length* 4 *and to choose the* else *branch, only network N*<sup>1</sup> *is able to perform the update operation. Formally:*

*N*<sup>1</sup> <sup>4</sup> *<sup>N</sup>*<sup>2</sup> *false*@office4 −−−−−−→ *<sup>N</sup>*<sup>3</sup> *upd*/*agency*[*test4*]/*dest*@office4 −−−−−−−−−−−−−−→ *N*<sup>4</sup> *upd*/*agency*[*test4*]/*dest*@office4

$$\begin{array}{l} \text{N}\_{1}^{\prime} \xhookrightarrow{4} \text{N}\_{2}^{\prime} \xrightarrow{\text{fulsle00:fücte\_{4}}} \text{N}\_{3}^{\prime} \xhookrightarrow{\text{fysle}/\text{age}/\text{test}\_{4}/\text{/}\text{ded}^{\prime}\text{00}\text{III}\text{Cl}\text{e}}\\ \text{N}\_{1}^{\prime\prime} \xhookrightarrow{\text{4}} \text{N}\_{2}^{\prime\prime} \xrightarrow{\text{fulsle0:föcte\_{4}}} \text{N}\_{3}^{\prime\prime} \xhookrightarrow{\text{Input4}/\text{test}\_{4}/\text{/}\text{dot}^{\prime}\text{/}\text{dot}^{\prime}} \end{array}$$

*where the networks N*2*, N*3*, N*4*, N* <sup>2</sup>*, N* <sup>3</sup>*, N* <sup>2</sup> *and N* <sup>3</sup> *in* knowTIMO *are obtained by using the rules of Tables 2 and 3.*

*3.2. Strong Bounded Timed Equivalences*

We provide some notations used in the rest of the paper:


*and*

$$\mu \stackrel{df}{=} \{ (\mathcal{N}, t, \mathcal{N}) \mid \mathcal{N} \in \mathcal{N}, \ t \in \mathbb{N} \}.$$

• The *inverse of a timed relation* R is

$$\mathcal{R}^{-1} \stackrel{df}{=} \{ (\mathcal{N}\_2, t, \mathcal{N}\_1) \mid (\mathcal{N}\_1, t, \mathcal{N}\_2) \in \mathcal{R} \}.$$

• The *composition of timed relations* R<sup>1</sup> and R<sup>2</sup> is

R1R2 *d f* = {(*N*, *t*, *N*)| ∃*N* ∈N : (*N*, *t*, *N* )∈R1∧(*N* , *t*, *N*)∈R2} .

• If R is a timed relation and *t* ∈ N, then

$$\mathcal{R}\_t \stackrel{df}{=} \{ (\mathcal{N}\_1, \mathcal{N}\_2) \mid (\mathcal{N}\_1, t, \mathcal{N}\_2) \in \mathcal{R} \}.$$

is R's *t*-*projection*. We also denote R<sup>∞</sup> *d f* = *<sup>t</sup>*∈<sup>N</sup> R*t*.

• A timed relation R is a timed equivalence if R<sup>∞</sup> is an equivalence relation, and is an equivalence up-to time *<sup>t</sup>* ∈ N if <sup>0</sup>≤*t*<*<sup>t</sup>* R*t* is an equivalence relation.

The equivalence ∼ requires an exact match of transitions of two networks during their entire evolutions. Sometimes this requirement is too strong. In many situations this requirement is relaxed [5], and real-time systems are allowed to behave in an expected way up to a certain amount *t* of time units. This impels one to define *bounded* timed equivalences up-to a given time *t*.

**Definition 2** (Strong bounded timed bisimulation)**.**

*Let* R⊆N× N × N *be a symmetric timed relation on* N *and on networks in* knowTIMO *.*

	- (*N*1, *t*, *N*2) ∈ R *and N*<sup>1</sup> *λ* −→ *N* <sup>1</sup> *implies that there exists N* <sup>2</sup> ∈ N *such that <sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* 2 *and* (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ R *;*
	- (*N*1, *t*, *N*2) ∈ R *and N*<sup>1</sup> *t N* <sup>1</sup> *implies that there exists N* <sup>2</sup> ∈ N *such that N*<sup>2</sup> *t N* 2 *and* (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ R *.*

The following results illustrate some properties of the strong bounded timed bisimulations. In particular, we prove that the equivalence relation (that is strictly included in relation ∼) is the largest strong bounded timed bisimulation.

#### **Proposition 6.**


#### **Proof.**

	- (a) The identity relation *ι* is a strong bounded timed bisimulation.
		- i. Assume (*N*, *<sup>t</sup>*, *<sup>N</sup>*) <sup>∈</sup> *<sup>ι</sup>*. Consider *<sup>N</sup> <sup>λ</sup>* −→ *N* ; then (*N* , *t*, *N* ) ∈ *ι* .
		- ii. Assume (*N*, *<sup>t</sup>*, *<sup>N</sup>*) <sup>∈</sup> *<sup>ι</sup>*. Consider *<sup>N</sup> <sup>t</sup> N* ; then (*N* , *t* − *t* , *N* ) ∈ *ι* .
	- (b) The inverse of a strong bounded timed bisimulation is a strong bounded timed bisimulation.
		- i. Assume (*N*1, *<sup>t</sup>*, *<sup>N</sup>*2)∈R<sup>−</sup>1, namely (*N*2, *<sup>t</sup>*, *<sup>N</sup>*1)∈R. Consider *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* 2; then for some *N* <sup>1</sup> we have *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup> and (*N* <sup>2</sup>, *t*, *N* <sup>1</sup>) ∈ R, namely (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ R<sup>−</sup>1. By similar reasoning, if *<sup>N</sup>*<sup>1</sup> *λ* −→ *N* <sup>1</sup> then we can find *N* <sup>2</sup> such that *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> and (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ R<sup>−</sup>1.
		- ii. Assume (*N*1, *<sup>t</sup>*, *<sup>N</sup>*2) ∈ R<sup>−</sup>1, namely (*N*2, *<sup>N</sup>*1) ∈ R. Consider *<sup>N</sup>*<sup>2</sup> *t N* 2; then for some *N* <sup>1</sup> we have *N*<sup>1</sup> *t N* <sup>1</sup> and (*N* <sup>2</sup>, *t* − *t* , *N* <sup>1</sup>) ∈ R, namely (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ R<sup>−</sup>1. By similar reasoning, if *<sup>N</sup>*<sup>1</sup> *t N* <sup>1</sup> then we can find *N* <sup>2</sup> such that *N*<sup>2</sup> *t N* <sup>2</sup> and (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ R<sup>−</sup>1.
	- (c) The composition of strong bounded timed bisimulations is a strong bounded timed bisimulation.
		- i. Assume (*N*1, *t*, *N*2) ∈ R1R2. Then for some *N* we have (*N*1, *t*, *N*) ∈ R<sup>1</sup> and (*N*, *t*, *N*2) ∈ R2. Consider *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup>; then for some *N* , since (*N*1, *<sup>t</sup>*, *<sup>N</sup>*) ∈ R1, we have *<sup>N</sup> <sup>λ</sup>* −→ *N* and (*N* <sup>1</sup>, *t*, *N* ) ∈ R1. Also, since (*N*, *t*, *N*2) ∈ R<sup>2</sup> we have for some *N* <sup>2</sup> that *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→*N* <sup>2</sup> and (*N* , *t*, *N* <sup>2</sup>)∈R2. Thus, (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>)∈R1R2. By similar reasoning, if *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup> and (*N* , *t*, *N* <sup>2</sup>) ∈ R2.
	- i. Assume (*N*1, *<sup>t</sup>*, *<sup>N</sup>*2) ∈ *<sup>i</sup>*∈*I*R*i*. Then for some *i* ∈ *I* we have that (*N*1, *t*, *N*2) ∈ R*i*. Consider *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup>; then for some *N* <sup>2</sup>, since (*N*1, *<sup>t</sup>*, *<sup>N</sup>*2) ∈ R*i*, we have *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> and (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ R*i*. Thus, (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* <sup>R</sup>*i*. By similar reasoning, if *<sup>N</sup>*<sup>2</sup> *<sup>λ</sup>* −→ *N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *λ* −→ *N* <sup>1</sup> and (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ R*i*, namely (*N* <sup>1</sup>, *t*, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*.
	- ii. Assume (*N*1, *<sup>t</sup>*, *<sup>N</sup>*2) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. Then for some *i* ∈ *I* we have that (*N*1, *t*, *N*2) ∈ R*i*. Consider *N*<sup>1</sup> *t N* <sup>1</sup>; then for some *N* <sup>2</sup>, since (*N*1, *t*, *N*2) ∈ R*i*, we have *N*<sup>2</sup> *t N* <sup>2</sup> and (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ R*i*. Thus, (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. By similar reasoning, if *N*<sup>2</sup> *t N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *t N* <sup>1</sup> and (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ R*i*, namely (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*.
	- (a) Reflexivity: For any network *N*, *N N* results from the fact that the identity relation is a strong bounded timed bisimulation.
	- (b) Symmetry: If *N N* , then (*N*, *t*, *N* ) ∈ R for some strong bounded timed bisimulation R. Hence (*N* , *<sup>t</sup>*, *<sup>N</sup>*) ∈ R<sup>−</sup>1, and so *<sup>N</sup> <sup>N</sup>* because the inverse relation is a strong bounded timed bisimulation.
	- (c) Transitivity: If *N N* and *N N* then (*N*, *t*, *N* ) ∈ R<sup>1</sup> and (*N* , *t*, *N*) ∈ R<sup>2</sup> for some strong bounded timed bisimulations R<sup>1</sup> and R2. Thus, it holds that (*N*, *t*, *N*) ∈ R1R2, and so *N N* due to the fact that the composition relation is a strong bounded timed bisimulation.

The next result claims that strong bounded timed equivalence *<sup>t</sup>* over processes is preserved even if the local knowledge of the agents is expanded. This is consistent with the fact that the processes affect the same portion of their knowledge.

$$\begin{array}{rcl}\textbf{Proposition 7.} \quad \textit{If } K\_{ij}' \subseteq K\_{ij'}'' \text{ for } 1 \le i \le n, \, 1 \le j \le m \text{, then} \\\quad |\_{i=1}^{n} \, \textit{l}\_{i}[[(|\/|\_{j=1}^{m} \, \textit{P}\_{ij} \rhd K\_{ij}'] ]\; \simeq \, |\_{i=1}^{n} \, \textit{l}\_{i}[[(|\/|\_{j=1}^{m} \, \textit{P}\_{ij} \rhd K\_{ij}' ]]\; \mathtt{I}\_{i} \; \textit{I}\_{j}' \; \textit{J}\_{i}'] . \end{array}$$

**Proof.** We show that S is a strong bounded timed bisimulation, where:



• Let us assume that | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>t</sup> N* . Then there exists *P ij*, 1 ≤ *i* ≤ *n*, 1 ≤ *j* ≤ *m*, such that | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>t</sup>* | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *P ij* - *K ij*]] = *N* . Then there exists *N* = | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *P ij* - *K ij*]] such that | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>t</sup> <sup>N</sup>*. Since *K ij* ⊆ *K ij*, 1 ≤ *i* ≤ *n*, 1 ≤ *j* ≤ *m*, clearly (*N* , *t* − *t* , *N*) ∈ S.

The symmetric cases follow by similar arguments.

The following result shows that strong bounded timed bisimulation is preserved even after complete computational steps of two networks in knowTIMO .

**Proposition 8.** *Let N*1, *N*<sup>2</sup> *be two* knowTIMO *networks.*

*If N*<sup>1</sup> *<sup>t</sup> N*<sup>2</sup> *and N*<sup>1</sup> Λ,*t* ==⇒*N* 1*, then there is N* <sup>2</sup> ∈N *such that N*<sup>2</sup> Λ,*t* ==⇒*N* <sup>2</sup> *and N* <sup>1</sup> *t*−*t N* 2*.*

**Proof.** Assuming that the finite multiset of actions Λ contains the labels {*λ*1, ... , *λk*}, then the complete computational step *N*<sup>1</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>1</sup> can be detailed as *N*<sup>1</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>1</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>1</sup> *<sup>λ</sup><sup>k</sup>* −→ *<sup>N</sup><sup>k</sup>* 1 *t N* 1. Note that *N*<sup>1</sup> *<sup>t</sup> N*<sup>2</sup> means that (*N*1, *t*, *N*2) ∈. Since *N*<sup>1</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>1</sup> and (*N*1, *t*, *N*2) ∈, then according to Definition 2 there exists *N*<sup>1</sup> <sup>2</sup> ∈ N such that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>2</sup> and (*N*<sup>1</sup> <sup>1</sup> , *<sup>t</sup>*, *<sup>N</sup>*<sup>1</sup> <sup>2</sup> ) ∈. The same reasoning can be applied for another *k* steps, meaning that there exist *N*<sup>2</sup> <sup>2</sup> , ... , *<sup>N</sup><sup>k</sup>* <sup>2</sup> , *N* 2 ∈ N such that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>2</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>2</sup> *<sup>λ</sup><sup>k</sup>* −→ *<sup>N</sup><sup>k</sup>* 2 *t N* <sup>2</sup> and (*N* <sup>1</sup>, *t* − *t* , *N* <sup>2</sup>) ∈, namely *N* <sup>1</sup> *t*−*t N* 2. The definition of a complete computational step implies that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> −→ *<sup>N</sup>*<sup>1</sup> <sup>2</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>2</sup> *<sup>λ</sup><sup>k</sup>* −→ *<sup>N</sup><sup>k</sup>* 2 *t N* <sup>2</sup> can be written as *N*<sup>2</sup> Λ,*t* ==⇒ *N* <sup>2</sup>. Thus, we obtained that there exists *N* <sup>2</sup> ∈ N such that *N*<sup>2</sup> Λ,*t* ==⇒ *N* <sup>2</sup> and *N* <sup>1</sup> *t*−*t N* <sup>2</sup> (as desired).

Strong bounded timed bisimulation satisfies the property that if two networks are equivalent up-to a certain deadline *t*, they are equivalent up-to any deadline *t* before *t*, i.e., *t* ≤ *t*.

#### **Proposition 9.** *If N <sup>t</sup> N and t* ≤ *t, then N t N .*

**Proof.** Assume *N <sup>t</sup> N* and that there exist the networks *N*1, ... , *Nk* ∈ N , the set of actions <sup>Λ</sup>1, ... , <sup>Λ</sup>*<sup>k</sup>* and the timers *<sup>t</sup>*1, ... , *tk* <sup>∈</sup> <sup>N</sup> such that *<sup>N</sup>* <sup>Λ</sup>1,*t*<sup>1</sup> ===<sup>⇒</sup> *<sup>N</sup>*<sup>1</sup> ... <sup>Λ</sup>*k*,*tk* ===<sup>⇒</sup> *Nk* and also *t* = *t*<sup>1</sup> + ... + *tk*. According to Proposition 8, there exist the networks *N* <sup>1</sup>, ... , *N k* ∈ N such that *<sup>N</sup>* <sup>Λ</sup>1,*t*<sup>1</sup> ===<sup>⇒</sup> *<sup>N</sup>* <sup>1</sup> ... <sup>Λ</sup>*k*,*tk* ===<sup>⇒</sup> *<sup>N</sup> <sup>k</sup>*, and also *N*<sup>1</sup> *t*−*t*<sup>1</sup> *N* <sup>1</sup>, ..., *Nk* <sup>0</sup> *N <sup>k</sup>*. Since *t* ≤ *t*, then there exists an *l* ≤ *k* and a *t* ∈ N such that *t*<sup>1</sup> + ... + *tl* + *t* = *t* . By using Theorem 1, it holds that there exists *<sup>N</sup>*<sup>1</sup> such that *<sup>N</sup>* <sup>Λ</sup>1,*t*<sup>1</sup> ===<sup>⇒</sup> *<sup>N</sup>*<sup>1</sup> ... <sup>Λ</sup>*l*,*tl* ==<sup>⇒</sup> *Nl* Λ*l*+1,*t* ====⇒ *<sup>N</sup>*1. In a similar manner, by using Theorem 1, it holds that there exists *<sup>N</sup>*<sup>2</sup> such that *<sup>N</sup>* <sup>Λ</sup>1,*t*<sup>1</sup> ===<sup>⇒</sup> *<sup>N</sup>* <sup>1</sup> ... <sup>Λ</sup>*l*,*tl* ==<sup>⇒</sup> *N l* Λ*l*+1,*t* ====⇒ *<sup>N</sup>*2. Since *<sup>N</sup>*<sup>1</sup> and *<sup>N</sup>*<sup>2</sup> can perform only time passing steps of length at most *tl*<sup>+</sup><sup>1</sup> − *t* , this means that *<sup>N</sup>*<sup>1</sup> <sup>0</sup> *<sup>N</sup>*2, However, according to Definition 2, this means that we obtain the desired relation *N t N* because the networks *N* and *N* can match their behaviour for *t* steps.

The next example illustrates that the relation *<sup>t</sup>* is able to treat as bisimilar some multi-agent systems that are not bisimilar using the relation ∼ .

**Example 3.** *Let us consider the networks of Example 2, namely:*

*N*<sup>1</sup> = office4[[C <sup>2</sup>(office4) - *K*C2]]*, N* <sup>1</sup> = office4[[C <sup>2</sup>(office4) - *K* C2]]*, N* <sup>1</sup> = office4[[C <sup>2</sup>(office4) - *K* C2]]*,*

*where the knowledge of the agents is defined as:*

*K*C2 = *agency* | office4; *dest* | *ε price* | *ε , K* C2 = *agency* | office5; *dest* | *ε price* | *ε , K* C2 = ∅*.*

*Even if it holds that N* <sup>1</sup> ∼ *N* <sup>1</sup> *while N*<sup>1</sup> ∼ *N* <sup>1</sup> *and N*<sup>1</sup> ∼ *N* <sup>1</sup> *, by applying Definition 2, it results that N*1*, N* <sup>1</sup> *and N* <sup>1</sup> *are strong bounded timed bisimilar before the* 4*th time unit since they have the same evolutions during this deadline, namely N* <sup>1</sup> <sup>4</sup> *N* <sup>1</sup> *, N*<sup>1</sup> <sup>4</sup> *N* <sup>1</sup> *and N*<sup>1</sup> <sup>4</sup> *N* 1 *. If t* > 4*, we have that N* <sup>1</sup> *<sup>t</sup> N* <sup>1</sup> *, while N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> *and N*<sup>1</sup> *<sup>t</sup> N* <sup>1</sup> *. Thus, both Definitions 1 and 2 return the same relations among N*1*, N* <sup>1</sup> *and N* <sup>1</sup> *for t* > 4*.*

*This example illustrates also the strict inclusion relation from item* 4 *of Proposition 6.*

#### *3.3. Weak Knowledge Equivalences*

Both equivalence relations ∼ and require an exact match of transitions and time steps of two networks in knowTIMO ; this makes them too restrictive. We can introduce a weaker version of network equivalence by looking only at the steps that affect the knowledge data, namely the *create* and *update* steps. Thus, we introduce a knowledge equivalence in order to distinguish between networks based on the interaction of the agents with their local knowledge: the networks are equivalent if we observe only *create* and *update* actions along same paths, regardless of the values added to the knowledge.

**Definition 3** (Weak knowledge bisimulation)**.** *Let* R⊆N ×N *be a symmetric binary relation over networks in* knowTIMO *.*

	- (*N*1, *N*2) ∈ R *and N*<sup>1</sup> *createf* @*l* =====⇒∗*N* <sup>1</sup> *implies that there exists N* <sup>2</sup> ∈ N *such that N*<sup>2</sup> *createf* @*l* =====⇒∗*N* <sup>2</sup> *and* (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R *;*
	- (*N*1, *N*2) ∈ R *and N*<sup>1</sup> *updp*@*l* ====⇒∗*N* <sup>1</sup> *implies that there exists N* <sup>2</sup> ∈ N *such that N*<sup>2</sup> *updp*@*l* ====⇒∗*N* <sup>2</sup> *and* (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R *;*

The following results present some properties of the weak knowledge bisimulations. In particular, we prove that the equivalence relation ∼= (that is strictly included in relation ∼) is the largest weak knowledge bisimulation.

#### **Proposition 10.**


#### **Proof.**

	- (a) The identity relation *Id*<sup>R</sup> is a weak knowledge bisimulation.
		- i. Assume (*N*, *<sup>N</sup>*) <sup>∈</sup> *Id*R. Consider *<sup>N</sup> createf* @*<sup>l</sup>* =====⇒∗*N* ; then (*N* , *N* ) ∈ *Id*<sup>R</sup> .
	- i. Assume (*N*1, *<sup>N</sup>*2)∈R<sup>−</sup>1, namely (*N*2, *<sup>N</sup>*1)∈R. Consider *<sup>N</sup>*<sup>2</sup> *createf* @*l* =====⇒∗*N* 2; then for some *N* <sup>1</sup> we have *N*<sup>1</sup> *createf* @*l* =====⇒∗*N* <sup>1</sup> and (*N* <sup>2</sup>, *N* <sup>1</sup>) ∈ R, namely (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R<sup>−</sup>1. By similar reasoning, if *<sup>N</sup>*<sup>1</sup> *createf* @*l* =====⇒∗*N* <sup>1</sup> then we can find *N* <sup>2</sup> such that *N*<sup>2</sup> *createf* @*l* =====⇒∗*N* <sup>2</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R<sup>−</sup>1.
	- ii. Assume (*N*1, *<sup>N</sup>*2)∈R<sup>−</sup>1, namely (*N*2, *<sup>N</sup>*1)∈R. Consider *<sup>N</sup>*<sup>2</sup> *updf* @*l* ====⇒∗*N* 2; then for some *N* <sup>1</sup> we have *N*<sup>1</sup> *updf* @*l* ====⇒∗*N* <sup>1</sup> and (*N* <sup>2</sup>, *N* <sup>1</sup>) ∈ R, namely (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R<sup>−</sup>1. By similar reasoning, if *<sup>N</sup>*<sup>1</sup> *updf* @*l* ====⇒∗*N* <sup>1</sup> then we can find *N* <sup>2</sup> such that *N*<sup>2</sup> *updf* @*l* ====⇒∗*N* <sup>2</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R<sup>−</sup>1.
	- ii. Assume (*N*1, *N*2) ∈ R1R2. Then for some *N* we have (*N*1, *N*) ∈ R<sup>1</sup> and (*N*, *N*2) ∈ R2. Consider *N*<sup>1</sup> *updf* @*l* ====⇒∗*N* <sup>1</sup>; then for some *N* , since (*N*1, *<sup>N</sup>*) ∈ R1, we have *<sup>N</sup> updf* @*<sup>l</sup>* ====⇒∗*N* and (*N* <sup>1</sup>, *N* ) ∈ R1. Also, since (*N*, *N*<sup>2</sup> ∈R<sup>2</sup> we have for some *N* <sup>2</sup> that *N*<sup>2</sup> *updf* @*l* ===⇒∗ *N* <sup>2</sup> and (*N* , *N* <sup>2</sup>) ∈R2. Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R1R2. By similar reasoning, if *N*<sup>2</sup> *updf* @*l* ====⇒∗*N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *updf* @*l* ====⇒∗*N* <sup>1</sup> and (*N* , *N* <sup>2</sup>) ∈ R2.
	- i. Assume (*N*1, *<sup>N</sup>*2) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. Then for some *<sup>i</sup>* ∈ *<sup>I</sup>* we have (*N*1, *<sup>N</sup>*2) ∈ R*i*. Consider *N*<sup>1</sup> *createf* @*l* =====⇒∗*N* <sup>1</sup>; then for some *N* <sup>2</sup>, since (*N*1, *N*2) ∈ R*i*, we have *N*<sup>2</sup> *createf* @*l* =====⇒∗*N* <sup>2</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*<sup>i</sup>* . Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. By similar reasoning, if *N*<sup>2</sup> *createf* @*l* =====⇒∗*N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *createf* @*l* =====⇒∗ *N* <sup>1</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*<sup>i</sup>* , namely (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. ii. Assume (*N*1, *<sup>N</sup>*2) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. Then for some *<sup>i</sup>* ∈ *<sup>I</sup>* we have (*N*1, *<sup>N</sup>*2) ∈ R*i*. Consider *N*<sup>1</sup> *updf* @*l* ====⇒∗*N* <sup>1</sup>; then for some *N* <sup>2</sup>, since (*N*1, *N*2) ∈ R*i*, we have *N*<sup>2</sup> *updf* @*l* ====⇒∗*N* <sup>2</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*<sup>i</sup>* . Thus, (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*. By similar reasoning, if *N*<sup>2</sup> *updf* @*l* ====⇒∗*N* <sup>2</sup> then we can find *N* <sup>1</sup> such that *N*<sup>1</sup> *updf* @*l* ====⇒∗ *N* <sup>1</sup> and (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ R*<sup>i</sup>* , namely (*N* <sup>1</sup>, *N* <sup>2</sup>) ∈ *<sup>i</sup>*∈*<sup>I</sup>* R*i*.
	- (a) Reflexivity: For any network *N*, *N* ∼= *N* results from the fact that the identity relation is a weak knowledge bisimulation.

The next result claims that weak knowledge equivalence ∼= among processes is preserved even if the local knowledge of the agents is expanded. This is consistent with the fact that the processes affect the same portion of their knowledge.

$$\begin{array}{c} \textbf{Proposition 11.} \quad \textit{f}\,\,\,\mathsf{K}\_{ij}^{\prime} \subseteq \mathsf{K}\_{ij}^{\prime\prime} \,\,\, for \,\,1 \le i \le n, \,\, 1 \le j \le m \text{, then} \\\quad \quad \quad \quad \quad \quad \,\,\_{i=1}^{n}\,\,l\_{i}[[\,\vert\!\vert\_{j=1}^{m}\,\,\,P\_{ij}\;\rhd\;\,\,\,K\_{ij}^{\prime}\rceil] \stackrel{\simeq}{\simeq} \,\,\,\,\,l\_{i=1}^{n}\,\,l\_{i}[[\;\vert\!\vert\_{j=1}^{m}\,\,P\_{ij}\;\mapsto\,\,\&\,\prime\_{ij}^{\prime\prime}\rceil]. \end{array}$$

**Proof.** We show that S is a weak knowledge bisimulation, where:

S = {(| *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]] , | *n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* -*K ij*]]) : *K ij* ⊆*K ij*, 1≤*i*≤*n*, 1≤ *j*≤*m*}. The proof is by induction on the last performed step. Let us assume that

*n <sup>i</sup>*=<sup>1</sup> *li*[[||*<sup>m</sup> <sup>j</sup>*=<sup>1</sup> *Pij* - *K ij*]] *<sup>λ</sup>* <sup>=</sup>⇒∗*N* . Depending on the value of *λ*, there are several cases:



• Consider *<sup>λ</sup>* = *updp*@*l1*. Then there exists *<sup>P</sup>*<sup>11</sup> such that *<sup>l</sup>*1[[*P*<sup>11</sup> - *K* <sup>11</sup> ||*<sup>m</sup> <sup>j</sup>*=<sup>2</sup> *P*1*<sup>j</sup>* - *K* 1*j* ]]


The symmetric cases follow by similar arguments.

The following result shows that weak knowledge bisimulation is preserved after complete computational steps of two networks in knowTIMO only if the knowledge is modified at least once during such a step.

#### **Proposition 12.** *Let N*1, *N*<sup>2</sup> *be two* knowTIMO *networks and* ∃*createf* @*l* ∈ Λ *or* ∃*updf* @*l*∈Λ*. If N*<sup>1</sup> ∼= *N*<sup>2</sup> *and N*<sup>1</sup> <sup>Λ</sup>,*<sup>t</sup>* ==⇒*N* <sup>1</sup>*, then there exists N*<sup>2</sup> ∈N *such that N*<sup>2</sup> <sup>Λ</sup>,*<sup>t</sup>* ==⇒ <sup>2</sup> *and N*<sup>1</sup> ∼= *N* 2*.*

**Proof.** Assuming that the finite multiset of actions Λ contains the labels {*λ*1, ... , *λk*} that denote modifications to the knowledge, then the complete computational step *N*<sup>1</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* 1 can be detailed as *N*<sup>1</sup> *<sup>λ</sup>*<sup>1</sup> <sup>=</sup>⇒∗*N*<sup>1</sup> <sup>1</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>1</sup> *<sup>λ</sup><sup>k</sup>* <sup>=</sup>⇒∗*N* <sup>1</sup>. Since *N*<sup>1</sup> *<sup>λ</sup>*<sup>1</sup> <sup>=</sup>⇒∗*N*<sup>1</sup> <sup>1</sup> and *N*<sup>1</sup> ∼= *N*2, then according to Definition 3 there exists *N*<sup>1</sup> <sup>2</sup> ∈ N such that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> <sup>=</sup>⇒∗*N*<sup>1</sup> <sup>2</sup> and *<sup>N</sup>*<sup>1</sup> <sup>1</sup> ∼= *<sup>N</sup>*<sup>1</sup> <sup>2</sup> . The same reasoning can be applied for another *k* times, meaning that there exist *N*<sup>2</sup> <sup>2</sup> , ... , *N* <sup>2</sup> ∈ N such that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> <sup>=</sup>⇒∗*N*<sup>1</sup> <sup>2</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>2</sup> *<sup>λ</sup><sup>k</sup>* <sup>=</sup>⇒∗*N* <sup>2</sup> and *N* <sup>1</sup> ∼= *N* <sup>2</sup>. By the definition of a complete computational step, it holds that *N*<sup>2</sup> *<sup>λ</sup>*<sup>1</sup> <sup>=</sup>⇒∗*N*<sup>1</sup> <sup>2</sup> ... *<sup>N</sup>k*−<sup>1</sup> <sup>2</sup> *<sup>λ</sup><sup>k</sup>* <sup>=</sup>⇒∗*N* <sup>2</sup> can be written as *N*<sup>2</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>2</sup>. Thus, we obtained that there exists *N* <sup>2</sup> ∈ N such that *N*<sup>2</sup> <sup>Λ</sup>,*<sup>t</sup>* ==<sup>⇒</sup> *<sup>N</sup>* <sup>2</sup> and *N* <sup>1</sup> ∼= *N* <sup>2</sup> (as desired).

The next example illustrates that the relation ∼= is able to treat bisimilar systems that are not bisimilar using the relation ∼.

**Example 4.** *Consider the network N*<sup>1</sup> *of Example 2, and a network*

*N* <sup>1</sup> = office4[[C <sup>2</sup> (office4) -*K*C2]]*,*

*in which the client can perform only an update action:*

C <sup>2</sup> (office4) = *update*(/*agency*[*test4*]/*dest*, *destC2*,*1*)*.*

*According to Definition 1, it holds that N*<sup>1</sup> ∼ *N* <sup>1</sup> *. This is due to the fact that the network N*<sup>1</sup> *can perform a time step of length* <sup>4</sup> *and choose the* else *branch, while the network <sup>N</sup>* <sup>1</sup> *can perform only the update operation. Formally:*

*upd*/*agency*[*test4*]/*dest*@office4

2

*and*

*N*<sup>1</sup> <sup>4</sup> *<sup>N</sup>*<sup>2</sup> *false*@office4 −−−−−−→ *<sup>N</sup>*<sup>3</sup> −−−−−−−−−−−−−−→ *N*<sup>4</sup> *upd*/*agency*[*test4*]/*dest*@office4

> *upd*/*agency*[*test4*]/*dest*@office4 −−−−−−−−−−−−−−→ *N*4*,*

*N* 1 −−−−−−−−−−−−−−→ *N*

*N*<sup>1</sup> =⇒<sup>∗</sup> *N*<sup>3</sup>

*The above reductions can also be written as*

*and*

*N* <sup>1</sup> =⇒<sup>∗</sup> *N* 1 *upd*/*agency*[*test4*]/*dest*@office4 −−−−−−−−−−−−−−→ *N* 2 *.*

*By applying Definition 3, it results that N*<sup>1</sup> *and N* <sup>1</sup> *are weak knowledge bisimilar because they are able to perform an update on the same path at the same location, i.e., N*<sup>1</sup> ∼= *N* 1 *.*

*This example is also an illustration of the strict inclusion relation from item* 4 *of Proposition 10.*

#### **4. Conclusions and Related Work**

In multi-agent systems, knowledge is usually treated by using epistemic logics [6]; in particular, the multi-agent epistemic logic [7,8]. These epistemic logics are modal logics describing different types of knowledge, being different not only syntactically, but also in expressiveness and complexity. Essentially, they are based on two concepts: Kripke structures (to model their semantics) and logic formulas (to represent the knowledge of the agents).

The initial version of TIMO presented in [1] leads to some extensions: with access permissions in perTIMO [9], with real-time in rTIMO [10], combining TIMO and the bigraphs [11] to obtain the BigTiMo calculus [12]. However, in all these approaches an implicit knowledge is used inside the processes. In this article we defined knowTIMO to describe multi-agent systems operating according to their accumulated knowledge. Essentially, the agents get an explicit representation of the knowledge about the other agents of a distributed network in order to decide their next interactions. The knowledge is defined as sets of trees whose nodes contain pairs of labels and values; this tree representation is similar to the data representation in Petri nets with structured data [13] and Xd*π* process calculus [14]. The network dynamics involving exchanges of knowledge between agents is presented by the operational semantics of this process calculus; its labelled transition system is able to capture the concurrent execution by using a multiset of actions. We proved that time passing in such a multi-agent system does not introduce any nondeterminism in the evolution of a network, and that the progression of the network is smooth (there are no time gaps). Several results are devoted to the relationship between the evolution of the agents and their knowledge.

According to [15], the notion of bisimulation was independently discovered in computer science [16,17], modal logic [18] and set theory [19,20]. Bisimulation is currently used in several domains: to test the behavioural equality of processes in concurrency [21]; to solve the state-explosion problem in model checking [22]; to index and compress semistructured data in databases [23,24]; to solve Markov decision processes efficiently in stochastic planning [25]; to understand for some languages their expressiveness in description logics [26]; and to study the observational indistinguishability and computational

complexity on data graphs in XPath (a language extending modal logic with equality tests for data) [27]. It is worth noting that the notion of bisimulation is related to the modal equivalence in various logics of knowledge and structures presented in [28]. In some of these logics it is proved that certain forms of bisimulation correspond to modal equivalence of knowledge, and this is used to compare the logics expressivity [29,30].

Inspired by the bisimulation notion defined in computer science, in this paper we defined and studied some specific behavioural equivalences involving the network knowledge and timing constraints on communication and migration; the defined behavioural equivalences are preserved during complete computational steps of two multi-agent systems. Strong timed bisimulation takes also into account timed transitions, being able to distinguish between different systems regardless of the evolution time; strong bounded timed bisimulation imposes limits for the evolution time, including the equivalences up to any bound below that deadline. A knowledge equivalence is able to distinguish between systems based on the interaction of the agents with their local knowledge. In the literature, a related but weaker/simpler approach of knowledge bisimulation appeared in [14], where the authors used only barbs (not equivalences), looking only at the *update* steps.

**Author Contributions:** All authors have read and agreed to the published version of the manuscript. All authors contributed equally to this work.

**Funding:** This research received no external funding.

**Conflicts of Interest:** The authors declare that there is no conflict of interest.

#### **References**

