In the gossip problem ([19, 5], see also  for an overview) a number of agents, each one knowing a piece of information (a secret) unknown to the others, communicate by one-to-one interactions (e.g., telephone calls). The result of each call is that the two agents involved in it learn all secrets the other agent knows at the time of the call. The problem consists in finding a sequence of calls which disseminates all the secrets among the agents in the group. It sparked a large literature in the 70s and 80s [19, 5, 10, 6, 18] typically focusing on establishing—in the above and other variants of the problem—the minimum number of calls to achieve dissemination of all the secrets. This number has been proven to be , where , the number of agents, is at least 4.
The above literature assumes a centralized perspective on the gossip problem: a planner schedules agents’ calls. In this paper we pursue a line of research first put forth in  by developing a decentralized theory of the gossip problem, where agents perform calls not according to a centralized schedule, but following individual epistemic protocols they run in a distributed fashion. These protocols tell the agents which calls to execute depending on what they know, or do not know, about the information state of the agents in the group. We call the resulting distributed programs (epistemic) gossip protocols.
Contribution of the paper and outline
The paper introduces a formal framework for specifying epistemic gossip protocols and for studying their computations in terms of correctness, termination, and fair termination (Section 2). It then defines and studies two natural protocols in which the interactions are unconstrained (Section 3) and four example gossip protocols in which agents are positioned on a directed ring and calls can happen only between neighbours (Section 4). Proofs are collected in the appendix.
2 Gossip protocols
We introduce first the syntax and semantics of gossip protocols.
We loosely use the syntax of the language CSP (Communicating Sequential Processes) of  that extends the guarded command language of  by disjoint parallel composition and commands for synchronous communication. CSP was realized in the distributed programming language OCCAM (see INMOS ).
The main difference is that we use as guards epistemic formulas and as communication primitives calls that do not require synchronization. Also, the syntax of our distributed programs is very limited. In order to define gossip protocols we introduce in turn calls and epistemic guards.
Throughout the paper we assume a fixed finite set of at least three agents. We assume that each agent holds exactly one secret and that there exists a bijection between the set of agents and the set of secrets. We denote by the set of all secrets (for propositions). Furthermore, it is assumed that each secret carries information identifying the agent to whom that secret belongs.
Each call concerns two agents, the caller ( below) and the agent called (). We distinguish three modes of communication of a call:
push-pull, written as or . During this call the caller and the called agent learn each other’s secrets,
push, written as . After this call the called agent learns all the secrets held by the caller,
pull, written as . After this call the caller learns all the secrets held by the called agent.
Variables for calls are denoted by , . Abusing notation we write to denote that agent is one of the two agents involved in the call (e.g., for we have and ). Calls in which agent is involved are denoted by .
2.1.2 Epistemic guards
Epistemic guards are defined as formulas in a simple modal language with the following grammar:
where and . Each secret is viewed as a distinct symbol. We denote the secret of agent by , the secret of agent by and so on. We denote the set of so defined formulas by and we refer to its members as epistemic formulas or epistemic guards. We read as ‘agent is familiar with the secret ’ (or ‘ belongs to the set of secrets knows about’) and as ‘agent knows that formula is true’. So this language is an epistemic language where atoms consist of ‘knowing whether’ statements about propositional atoms, if we view secrets as Boolean variables.
Atomic expressions in concern only who knows what secrets. As a consequence the language cannot express formally the truth of a secret . This level of abstraction suffices for the purposes of the current paper. However, expressions could be given a more explicit epistemic reading in terms of ‘knowing whether’. That is, ‘ is familiar with ’ can be interpreted (on a suitable Kripke model) as ‘ knows whether the secret is true or not’. This link is established in .
2.1.3 Gossip protocols
Before specifying what a program for agent is, let us first define the language with the following grammar:
with .111Alternatively, could be defined as the fragment of consisting of the formulae of form . In logic S5, it is easy to prove that each is logically equivalent to a formula .
By a component program, in short a program, for an agent we mean a statement of the form
where and each is such that and is the caller in .
Given an epistemic formula and a call , we call the construct a rule and refer in this context to as a guard.
We denote the set of rules as and abbreviate a set of rules with the same call to a single rule .
Intuitively, denotes a repeated execution of the rules, one at a time, where each time a rule is selected whose guard is true.
Finally, by a distributed epistemic gossip protocol, in short a gossip protocol, we mean a parallel composition of component programs, one for each agent. In order not to complicate matters we assume that each gossip protocol uses only one mode of communication.
Of special interest for this paper are gossip protocols that are symmetric. By this we mean that the protocol is a composition of the component programs that are identical modulo the names of the agents. Formally, consider a statement , where is a variable ranging over the set of agents and such that for each agent , is a component program for agent . Then the parallel composition of the programs, where , is called a symmetric gossip protocol.
We now move on to provide a formal semantics of epistemic guards, and then describe the computations of gossip protocols.
2.2.1 Gossip situations and calls
A gossip situation is a sequence , where for each agent . Intuitively, is the set of secrets is familiar with in situation . The initial gossip situation is the one in which each equals and is denoted by . The set of all gossip situations is denoted by . We say that an agent is an expert in a gossip situation if he is familiar in with all the secrets, i.e., if . The initial gossip situation reflects the fact that initially each agent is familiar only with his own secret, although it is not assumed this is common knowledge among the agents. In fact, in the introduced language we have no means to express the concept of common knowledge.
We will use the following concise notation for gossip situations. Sets of secrets will be written down as lists. e.g., the set will be written as . Gossip situations will be written down as lists of lists of secrets separated by dots. E.g., if there are three agents, and the situation ) will be written as .
Each call transforms the current gossip situation by modifying the set of secrets the agents involved in the call are familiar with. More precisely, the application of a call to a situation is defined as follows.
Definition 2.1 (Effects of calls)
A call is a function , so defined, for :
, where , , for ;
, where , , , for ;
, where , , , for .
The definition formalizes the modes of communications we introduced earlier. Depending on the mode, secrets are either shared between caller and callee (), they are pushed from the caller to the callee (), or they are retrieved by the caller from the callee ().
2.2.2 Call sequences
A call sequence is a (possibly infinite) sequence of calls, in symbols , all being of the same communication mode. The empty sequence is denoted by . We use to denote a call sequence and to denote the set of all call sequences. The set of all finite call sequences is denoted . Given a finite call sequence and a call we denote by the prepending of with , and by the postpending of with .
The result of applying a call sequence to a situation is defined by induction using Definition 2.1, as follows:
Let the set of agents be .
The top row lists the call sequence , while the bottom row lists the successive gossip situations obtained from the initial situation by applying the calls in the sequence: first , then and finally .
By applying an infinite call sequence to a gossip situation one obtains therefore an infinite sequence of gossip situations, where each is sequence . A call sequence is said to converge if for all input gossip situations the generated sequence of gossip situations reaches a limit, that is, there exists such that for all . Since the set of secrets is finite and calls never make agents forget secrets they are familiar with, it is easy to see the following.
All infinite call sequences converge.
However, as we shall see, this does not imply that all gossip protocols terminate. In the remainder of the paper, unless stated otherwise, we will assume the push-pull mode of communication. The reader can easily adapt our presentation to the other modes.
2.2.3 Gossip models
The set of all gossip situations is the set of all possible combinations of secret distributions among the agents. As calls progress in sequence from the initial situation, agents may be uncertain about which one of such secrets distributions is the actual one. This uncertainty is precisely the object of the epistemic language for guards we introduced earlier.
A gossip model (for a given set ) is a tuple , where each is the smallest relation satisfying the following inductive conditions (assume the mode of communication is push-pull):
[Step] Suppose .
If , then and .
If there exists and such that , then .
A gossip model with a designated finite call sequence is called a pointed gossip model.
For the push, respectively pull, modes of communication clause (ii) needs to be modified by requiring that for some , or , respectively.
For instance, by (i) we have . But we do not have since .
Let us flesh out the intuitions behind the above definition. Gossip models are needed in order to interpret the epistemic guards of gossip protocols. Since such guards are relevant only after finite sequences of calls, the domain of a gossip model is taken to consist only of finite sequences. Intuitively, those are the finite sequences that can be generated by a gossip protocol. Let us turn now to the relation. This is defined with the following intuitions in mind. First of all, no agent can distinguish the empty call sequence from itself—this is the base of the induction. Next, if two call sequences are indistinguishable for , then the same is the case if (i) we extend one of these sequences by a call in which is not involved or if (ii) we extend each of these sequences by a call of with the same agent (agent may be the caller or the callee), provided is familiar with exactly the same secrets after each of the new sequences has taken place—this is the induction step.222Notice that the definition requires a designated initial situation, which we assume to be .
The above intuitions are based on the following assumptions on the form of communication we presuppose: (i) At the initial situation, as communication starts, each agent knows only her own secret but considers it possible that the others may be familiar with all other secrets. In other words there is no such thing as common knowledge of the fact that ‘everybody knows exactly her own secret’. (ii) In general, each agent always considers it possible that call sequences (of any length) take place that do not involve her. These assumptions are weaker than the ones analyzed in .
We state without proof the following simple fact.
Each is an equivalence relation;
For all if , then , but not vice versa.
This prompts us to note also that according to Definition 2.4 sequences which make learn the same set of secrets may well be distinguishable for , such as, for instance, and . In the first one comes to know that knows is familiar with all secrets, while in the second one, she comes to know that knows is familiar with all secrets. Relation is so defined as to capture this sort of ‘higher-order’ knowledge.
2.2.4 Truth conditions for epistemic guards
Everything is now in place to define the truth of the considered formulas.
Let be a pointed gossip model with and . We define the satisfaction relation inductively as follows (clauses for Boolean connectives are omitted):
So formula is true (in a pointed gossip model) whenever secret belongs to the set of secrets agent is familiar with in the situation generated by the designated call sequence applied to the initial situation . The knowledge operator is interpreted as customary in epistemic logic using the equivalence relations .
Assume a gossip protocol that is a parallel composition of the component programs , one for each agent .
Given the gossip model we define the computation tree of as the smallest set of sequences satisfying the following inductive conditions:
[Step] If and then . In this case we say that a transition has taken place between and , in symbols, .
So is a (possibly infinite) set of finite call sequences that is iteratively obtained by performing a ‘legal’ call (according to protocol ) from a ‘legal’ (according to protocol ) call sequence.
A path in the computation tree of is a (possibly infinite) sequence of elements of , denoted by , where and each for some call and . A computation of is a maximal rooted path in the computation tree of .333Note that while the sequences that are elements of the computation tree of a protocol are always finite (although possibly infinite in number), computations can be infinite sequences (of finite call sequences).
The above definition implies that a call sequence is a leaf of the computation tree if and only if
We call the formula
the exit condition of the gossip protocol .
Obviously computation trees can be infinite, though they are always finitely branching. Further, note that this semantics for gossip protocols abstracts away from some implementation details of the calls. More specifically, we assume that the caller always succeeds in his call and does not require to synchronize with the called agent. In reality, the called agent might be busy, being engaged in another call. To take care of this one could modify each call by replacing it by a ‘call protocol’ that implements the actual call using some lower level primitives. We do not elaborate further on this topic.
Let us fix some more terminology. For , an agent is enabled in if and is disabled otherwise. So an agent is enabled if it can perform a call. An agent is selected in if it is the caller in the call that for some determines the transition in . Finally, a computation is called a fair computation if it is finite or each agent that is enabled in infinitely many sequences in is selected in infinitely many sequences in .
We note in passing that various alternative definitions of fairness are possible; we just focus on one of them. An interested reader may consult , where several fairness definitions (for instance one focusing on actions and not on agents) for distributed programs were considered and compared.
We conclude this section by observing the following. Our definition of computation tree for protocol presupposes that guards are interpreted over the gossip model . This means that when evaluating guards, agents consider as possible call sequences that cannot be generated by . In other words, agents do not know the protocol. To model common knowledge of the considered protocol in the gossip model one should take as the domain of the gossip model the underlying computation tree. However, the computation tree is defined by means of the underlying gossip model. To handle such a circularity an appropriate fixpoint definition is needed. We leave this topic for future work.
We are interested in proving the correctness of gossip protocols. Assume a gossip protocol that is a parallel composition of the component programs .
We say that is partially correct, in short correct, if in all situations sequences that are leaves of the computation tree of , for each agent
i.e., if for all situations sequences that are leaves of the computation tree of , each agent is an expert in the gossip situation .
We say furthermore that terminates if all its computations are finite and that fairly terminates if all its fair computations are finite.
In the next section we provide examples showing that partial correctness and termination of the considered protocols can depend on the assumed mode of communication and on the number of agents. In what follows we study various gossip protocols and their correctness. We begin with the following obvious observation.
For each protocol the following implications () hold, where stands for its termination and for its fair termination in a communication mode :
Protocol R3 given in Section 4 shows that none of these implications can be reversed. Moreover, it is not the case either that for each protocol :
Let and define the following expression:
Expression is defined analogously. Note that we denote by the secret of agent . Intuitively, means that agent is familiar with all the secrets that agent is familiar with, but not vice versa. So is familiar with a strict superset of the secrets is familiar with. Further, let stand for .
Consider now the following component programs:
for agent :
for agent :
for agent :
This protocol is correct. Indeed, initially no agent is an expert, hence both guards of are false. On the other hand, we have and , so both and . Consequently, initially both and are enabled. If the first call is granted to , this agent will call yielding the gossip situation . Now the guard of is false (since is still familiar only with his own secret , while is familiar with at least and and knows this). The guard of is still false. So now only is enabled. After his call of this yields the gossip situation . At this stage, only agent is enabled and after he calls both and all guards become false. Moreover, this protocol terminates. Indeed, the only computations are the ones in which first the calls and take place, in any order, followed by the calls and , also performed in any order.
However, if we use the push-pull direction type instead of push, then the situation changes. Indeed, after an arbitrary number of calls the formula is still true and hence is true, as well. Consequently, this call can be indefinitely repeated, so the protocol does not terminate.
3 Two symmetric protocols
In this section we consider protocols for the case when the agents form a complete graph. We study two protocols. We present them first for the communication mode push-pull. (Partial) correctness of the considered protocols does not depend on the assumed mode of communication.
Learn new secrets protocol (LNS)
Consider the following program for agent :
Informally, agent calls agent if is not familiar with ’s secret. Note that the guards of this protocol do not use the epistemic operator , but they are equivalent to the ones that do, as is equivalent to .
This protocol was introduced in  and studied with respect to the push-pull mode, assuming asynchronous communication. As noted there this protocol is clearly correct. Also, it always terminates since after each call the size of decreases. The same argument shows termination if the communication mode is pull.
However, if the communication mode is push, the protocol may fail to terminate, even fairly. To see it fix an agent and consider a sequence of calls in which each agent calls . At the end of this sequence becomes an expert but nobody is familiar with his secret. So any extension of this sequence is an infinite computation.
Let us consider now the possible call sequences generated by the computations of this protocol. Assume that there are agents. By the result mentioned in the introduction in each terminating computation at least calls are made.
The LNS protocol can generate such shortest sequences (among others). Indeed, let be the set of agents. Then the following sequence of calls
corresponds to a terminating computation.
The guards used in this protocol entail that after a call neither the call nor another call can take place, that is between each pair of agents at most one call can take place. Consequently, the longest possible sequence contains at most calls. Such a worst case can be generated by means of the following sequence of calls:
where for a natural number , stands for the sequence .444Other longest sequences are obviously possible, for instance: .
Hear my secret protocol (HMS)
Next, we consider a protocol with the following program for agent :
Informally, agent calls agent if he (agent ) does not know whether is familiar with his secret. To prove correctness of this protocol it suffices to note that its exit condition
implies . To prove termination it suffices to note that after each call the size of the set decreases.
If the communication mode is push, then the termination argument remains valid, since after the call agent still learns all the secrets agent is familiar with.
However, if the communication mode is pull, then the protocol may fail to terminate, even fairly. To see it fix an agent and consider the calls , where ranges over , arbitrarily ordered. Denote this sequence by . Consider now an infinite sequence of calls resulting from repeating indefinitely. It is straightforward to check that such a sequence corresponds to a possible computation. Indeed, in this sequence agent never calls and hence never learns any new secret. So for each the formula remains true and hence each agent remains enabled. Moreover, after the calls from took place agent is not anymore enabled. Hence the resulting infinite computation is fair.
4 Protocols over directed rings
In this section we consider the case when the agents are arranged in a directed ring, where . For convenience we take the set of agents to be . For , let and denote respectively the successor and predecessor of agent . That is, for , , , for , , and . For we define and by induction in the expected way. Again, when reasoning about the protocols we denote the secret of agent by . We consider four different protocols and study them with respect to their correctness and (fair) termination.
In this set up, a call sequence over a directed ring is a (possibly infinite) sequence of calls, all being of the same communication mode, and all involving an agent and . As before, we use to denote such a call sequence and to denote the set of all call sequences over a directed ring. In this section, unless stated otherwise, by a call sequence we mean a sequence over a directed ring. The set of all such finite call sequences is denoted . A gossip model for a directed ring is a tuple , where each is as in Definition 2.4. The truth definition is as before, and the notion of a computation tree for directed rings of a ring protocol is analogous to the notion defined before. Note that by restricting the domain in to , the ring network—and hence who is the successor of whom—becomes common knowledge.
When presenting the protocols we use the fact that is equivalent to .
Ring protocol R1
Consider first a gossip protocol with the following program for :
where denotes the mode of communication, so , or push-pull.
Informally, agent calls his successor, agent , if is familiar with some secret and he knows that his successor is not familiar with it.
Let . Protocol R1 terminates and is correct.
Termination and correctness do not both hold for the other communication modes. Consider first the pull communication mode, i.e., . Then the protocol does not always terminate. Indeed, each call can be repeated. Next, consider the push-pull communication mode. We show that then the protocol is not correct. Indeed, take
We claim that after the sequence of calls the exit condition of the protocol is true. To this end we consider each agent in turn.
After each agent , where is familiar the secrets of the agents . Moreover, because of the call agent knows that agent is familiar with these secrets. So the exit condition of agent is true.
To deal with agent note that . After the latter call sequence agent 1 becomes an expert. So after agent cannot know that agent 1 is not familiar with some secret. Consequently, after the exit condition of agent is true, as well. However, after agent is not an expert, so the protocol is indeed not correct.
In what follows we initially present the protocols assuming the push-pull mode of communication.
Ring protocol R2
Consider now a gossip protocol with the following program for agent :
where (recall) denotes the secret of agent . Informally, agent calls his successor, which is agent , if does not know that his successor is familiar with the secret of ’s predecessor, i.e., agent .
If then protocol R2 is correct.
However, this protocol is not correct for five or more agents. To see it consider the sequence of calls
where . After it the exit condition of the protocol is true. However, agent 3 is not familiar with the secret of agent 5.
Note that the same argument shows that the protocol in which we use instead of is incorrect, as well.
Moreover, this protocol does not always terminate. Indeed, one possible computation consists of an agent repeatedly calling his successor .
Ring protocol R3
Next, consider the following modification of protocol R2 in which we use the following program for agent :
Informally, agent calls his successor, agent , if is not familiar with all the secrets or does not know that his successor is familiar with the secret of his predecessor, agent .
This gossip protocol is obviously correct thanks to the fact that is part of the exit condition. However, it does not always terminate for the same reason as the previous one.
On the other hand, the following holds.
Protocol R3 fairly terminates.
The same conclusions concerning non termination and fair termination can be drawn for the push and the pull modes of communication. Indeed, for push it suffices to consider the sequence of calls after which agent becomes disabled, and for pull the sequence of calls after which agent becomes disabled.
Ring protocol R4
Finally, we consider a protocol that is both correct and terminates for the push-pull mode. Consider the following program for :
Informally, agent calls his successor, agent , if is familiar with some secret and he does not know whether his successor is familiar with it. Note the similarity with protocol R1.
Protocol R4 terminates and is correct.
If the communication mode is push, then the termination argument remains valid, since after the call agent still learns all the secrets that agent is familiar with and hence the above set decreases.
If the communication mode is pull, then the protocol may fail to terminate, because after the first call agent does not learn the secret of agent and consequently the call can be repeated. However, the situation changes when fairness is assumed.
For the pull communication mode protocol R4 fairly terminates.
Table 1 summarizes the termination properties of the protocols considered in the paper.
|Protocol||T||FT||T for||FT for||T for||FT for|
The aim of this paper was to introduce distributed gossip protocols, to set up a formal framework to reason about them, and to illustrate it by means of an analysis of selected protocols.
Our results open up several avenues for further research. First, our correctness arguments were given in plain English with occasional references to epistemic tautologies, such as , but it should be possible to formalize them in a customized epistemic logic. Such a logic should have a protocol independent component that would consist of the customary S5 axioms and a protocol dependent component that would provide axioms that depend on the mode of communication and the protocol in question. An example of such an axiom is the formula that we used when reasoning about protocol R2. To prove the validity of the latter axioms one would need to develop a proof system that allows us to compute the effect of the calls, much like the computation of the strongest postconditions in Hoare logics. Once such a logic is provided the next step will be to study formally its properties, including decidability. Then we could clarify whether the provided correctness proofs could be carried out automatically.
Second, generalizing further the ideas we introduced by considering directed rings, gossip protocols could be studied in interface with network theory (see  for a textbook presentation). Calls can be assumed to be constrained by a network, much like in the literature on ‘centralized’ gossip (cf. 
) or even have probabilistic results (i.e., secrets are passed with given probabilities). More complex properties of gossip protocols could then be studied involving higher-order knowledge or forms of group knowledge among neighbors (e.g., “it is common knowledge amongand her neighbors that they are all experts”), or their stochastic behavior (e.g., “at some point in the future all agents are experts with probability ”).
Third, it will be interesting to analyze the protocols for the types of calls considered in . They presuppose some form of knowledge that a call took place (for instance that given a call between and each agent noted the call but did not learn its content). Another option is to consider multicasting (calling several agents at the same time).
Finally, many assumptions of the current setup could be lifted. Different initial and final situations could be considered, for instance common knowledge of protocols could be assumed, or common knowledge of the familiarity of all agents with all the secrets upon termination could be required. Finally, to make the protocols more efficient passing of tokens could be allowed instead of just the transmission of secrets by means of calls.
We would like to thank Hans van Ditmarsch and the referees for helpful comments and Rahim Ramezanian for useful comments about Example 2.8. This work resulted from a research visit by Krzysztof Apt to Davide Grossi and Wiebe van der Hoek, sponsored by the 2014 Visiting Fellowship Scheme of the Department of Computer Science of the University of Liverpool. The first author is also a Visiting Professor at the University of Warsaw. He was partially supported by the NCN grant nr 2014/13/B/ST6/01807.
-  K. R. Apt, F. R. de Boer & E. R. Olderog (2009): Verification of Sequential and Concurrent Programs. Springer, doi:10.1007/978-1-84882-745-5.
-  K. R. Apt, N. Francez & S. Katz (1988): Appraising fairness in distributed languages. Distributed Computing 2(4), pp. 226–241, doi:10.1007/BF01872848.
-  M. Attamah, H. van Ditmarsch, D. Grossi & W. Van der Hoek (2014): Knowledge and gossip. In: Proceedings of ECAI’14, IOS Press, pp. 21–26.
-  B. Baker & R. Shostak (1972): Gossips and Telephones. Discrete Mathematics 2, pp. 197–193, doi:10.1016/0012-365X(72)90001-5.
-  R. Bumby (1981): A Problem with Telephones. SIAM Journal of Algorithms and Discrete Methods 2, pp. 13–18, doi:10.1137/0602002.
-  E. W. Dijkstra (1975): Guarded commands, nondeterminacy and formal derivation of programs. Communications of the ACM 18, pp. 453–457, doi:10.1145/360933.360975.
-  R. Fagin, J. Halpern, Y. Moses & M. Vardi (1997): Knowledge-Based Programs. Distributed Computing 10, pp. 199–225, doi:10.1007/s004460050038.
-  Ronald Fagin, Joseph Y. Halpern, Yoram Moses & Moshe Y. Vardi (1995): Reasoning about knowledge. The MIT Press, Cambridge.
-  A. Hajnal, E. C. Milner & E. Szemeredi (1972): A Cure for the Telephone Disease. Canadian Mathematical Bulletin 15, pp. 447–450, doi:10.4153/CMB-1972-081-0.
-  S. M. Hedetniemi, S. T. Hedetniemi & A. L. Liestman (1988): A survey of gossiping and broadcasting in communication networks. Networks 18(4), pp. 319–349, doi:10.1002/net.3230180406.
-  C. A. R. Hoare (1978): Communicating sequential processes. Communications of the ACM 21, pp. 666–677, doi:10.1145/359576.359585.
-  INMOS Limited (1984): Occam Programming Manual. Prentice-Hall International.
-  M. O. Jackson (2008): Social and Economic Networks. Princeton University Press.
-  R. Kurki-Suonio (1986): Towards programming with Knowledge Expressions. In: Proceedings of POPL’86, pp. 140–149, doi:10.1145/512644.512657.
-  J.-J. Ch. Meyer & W. van der Hoek (1995): Epistemic Logic for AI and Computer Science. Cambridge Tracts in Theoretical Computer Science 41, Cambridge University Press, doi:10.1017/CBO9780511569852.
-  R. Parikh & R. Ramanujam (1985): Distributed Processing and the Logic of Knowledge. In: Logic of Programs, LNCS 193, Springer, pp. 256–268, doi:10.1007/3-540-15648-8. Similar to JoLLI 12: 453–467, 2003.
-  Á Seress (1986): Quick Gossiping without Duplicate Transmissions. Graphs and Combinatorics 2, pp. 363–383, doi:10.1007/BF01788111.
-  R. Tijdeman (1971): On a telephone problem. Nieuw Archief voor Wiskunde 3(XIX), pp. 188–192.