{'fraction_non_alphanumeric': 0.0476594356548687, 'fraction_numerical': 0.005643451312999511, 'mean_word_length': 4.392436235708003, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 14, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
On Distributed Density in Tuple-based Coordination Languages

Inspired by the chemical metaphor, this paper proposes an extension of Linda-like languages in the aim of modeling the coordination of complex distributed systems. The new language manipulates finite sets of tuples and distributes a density among them. This new concept adds to the non-determinism inherent in the selection of matched tuples a non-determinism to the tell, ask and get primitives on the consideration of different tuples. Furthermore, thanks to de Boer and Palamidessi's notion of modular embedding, we establish that this new language strictly increases the expressiveness of the Dense Bach language introduced earlier and, consequently, Linda-like languages.


Introduction
The technological evolutions over the last recent years confirm the upward trends in a pervading of our everyday environments by new mobile devices injecting or retrieving information from very dynamic and dense networks. In order to garantee robustness and continuity of the services they propose, the global structure must be tolerant regarding any modification in topology, device technology or creation of new services. These constraints will be fulfilled if full self-organisation is incorporated as an inherent property of the coordination models. Coordination languages based on tuple spaces offer an elegant response to such constraints. The Bach language -a dialect of Linda developed at the University of Namur -is one of them, and permits to model in an elegant way the interaction between different components through the deposit and retrieval of tuples in a shared space. As its basic form only allows the manipulation of one tuple at a time and since the selection between several tuples matching a required one is provided in an non-deterministic fashion, a first extension was first proposed in [12] in the aim of enriching traditional data-based coordination languages by a notion of density attached to tuples, thereby yielding a new coordination language, called Dense Bach.
To illustrate the use of the dense tuples, let us consider the context of service oriented computing. Let us imagine a situation where a group of n researchers planing their presence to a conference want to book rooms in a hotel. Their query could naturally consist in getting n rooms in the tuple space of free rooms in any hotel, and to effectivelly book them only if all the n rooms are available, or if the number of rooms combined with their number of beds meets the required n amount. In a more scientific context, we could consider the chemical reactions between three elements N (nitrogen), O (oxygen) and S (sulphur) present in a reactor. Following the distribution -understood here in the chemical sense -of the global density between those three different reactants, some reactions will be more facilitated and others minder, and the concentration of the resulting products could alternate more in favour of one solution (like NO 2 ) or another (like SO 2 ).
Considering those two previous examples, we then propose in this paper as a next natural step to consider a set of tuples, among which the density is distributed. The new abstract language resulting from that extension strictly increases the expressiveness of Linda-like languages. It is still built upon the four primitives tell, ask, get and nask, accessing a tuplespace, also named subsequently store. However, it enhances it with a non-deterministic behavior of the tell, ask and get primitives with regard to which tuples from the set are considered.
Our purposes remain of a theoretical nature and, hence, for simplicity purposes, we shall consider in this paper a simplified version where tuples are taken in their simplest form of flat and unstructured tokens. Nevertheless, the resulting simplification of the matching process is orthogonal to our purposes and, consequently, our results can be directly extended to more general tuples.
This paper fits into the continuity of previous work done by the authors, among others of [5,8,9,12,16]. As a result, our approach follows the same lines of research, and employs de boer and Palamidessi's modular embedding to test the expressiveness of languages. The rest of this paper is consequently organized as follows. Section 2 presents our extension of the Dense Bach language, called Dense Bach with Distributed Density and, after the definition of the distribution of density on a list of tokens, defines an operational semantics. Section 3 provides a short presentation of modular embedding and, on that basis, proceeds with an exhaustive comparison of the relative expressive power of the languages Dense Bach and Dense Bach with Distributed Density. Finally, section 4 compares our work with related work, draws our conclusions and presents expectations for future work.

Densed Tuple-based Coordination Languages
This section exposes in four points the different densed tuple-based coordination languages, firstly by presenting their primitives, and secondly the different languages. The two last points present an operational semantic based on transition systems.

Primitives
We start by defining the Bach and Dense Bach languages [12] from which the language under study in this paper is an extension.

Bach and Dense Bach
The following definition formalizes how we attach a density to them. Definition 1. Let Stoken be a enumerable set, the elements of which are subsequently called tokens and are typically represented by the letters t and u. Define the association of a token t and a positive integer n ∈ N as a dense token. Such an association is typically denoted as t(n). Define then the set of dense tokens as the set SDtoken. Note that since Stoken and N are both enumerable, the set SDtoken is also enumerable.
Intuitively, a dense token t(m) represents the simultaneous presence of m occurrences of t. As a result, {t(m)} is subsequently used to represent the multiset {t, · · · ,t} composed of these m occurrences. Moreover, given two multisets of tokens σ and τ, we shall use σ ∪ τ to denote the multiset union of

Definition 2.
Define the set T of the token-based primitives as the set of primitives T generated by the following grammar: where t represents a token. Definition 3. Define the set of dense token-based primitives T d as the set of primitives T d generated by the following grammar: where t represents a token and m a positive natural number.
The primitives of the Bach language are essentially the Linda ones rephrased in a constraint-like setting. As a result, by calling store a multiset of tokens aiming at representing the current content of the tuple space, the execution of the tell(t) primitives amounts to enrich the store by an occurrence of t. The ask(t) and get(t) primitives check whether t is present on the store with the latter removing one occurrence. Dually, nask(t) tests whether t is absent from the store.
The primitives of the dense Bach language extend these primitives by simultaneously handling multiple occurrences. Accordingly, tell(t(m)) atomically puts m occurrences of t on the store and ask(t(m)) together with get(t(m)) require the presence of at least m occurrences of t with the latter removing m of them. Moreover, nask(t(m)) verifies that there are less than m occurrences of t.
These executions can be formalized by the transition steps of figures 1 and 2, where configurations are pairs of instructions, for the moment reduced to simple primitives, coupled to the contents of a store. Note that E is used to denote a terminated computation. As can be seen by the above description, the primitives of Bach are those of Dense Bach with a density of 1. Consequently, our explanation starts by the more general rules of figure 2. Rule (T d ) states that for any store σ and any token t with density m, the effect of the tell primitive is to enrich the current set of tokens by m occurrences of token t. Note that ∪ denotes multi-set union. Rules (A d ) and (G d ) specify the effect of ask and get primitives, both requiring the presence of at least m occurrences of t, but the latter also consuming them. Rule (N d ) defines the nask primitive, which tests for the absence of m occurrences of t. Note that there might be some provided there are less than m. It is also worth observing that thanks to the notation σ ⊎ {t(n)} one is sure that t does not occur in σ and consequently that there are exactly n occurrences of t. This does not apply for rules (A d ) and (G d ) for which it is sufficient to assume the presence of at least m occurrences, allowing σ to contain others. Figure 1 specifies the transition rules for the primitives of the Bach language. As expected, they amount to the rules of Figure 2 where the density m is taken to be 1 and the union symbol is interpreted on multi-sets.

Dense Bach with distributed density
A natural extension is to replace a token by a set of tokens and to distribute the density requirements on tokens. For instance, the primitive ask ([t, u, v] (6)) succeeds on a store containing one occurrence of t, two of u and three of v. Dually, the computation of tell ([t, u, v] (6)) may result in adding two occurrences of t on the store, three of u and one of v. The following definitions formalize this intuition. The distribution of the density over a set of tokens is formalized through the following distribution function.

Definition 5.
Define the distribution of tokens from dense sets of tokens to sets of tuples of dense tokens as follows: Note that, thanks to the definition of dense tokens, we assume above that the m i 's are positive integers. For the sake of simplicity, we shall call the set D([t 1 , · · · ,t p ](m)) the distribution of m over [t 1 , · · · ,t p ].
The distribution of an integer m over a set of tokens L has the potential to express the behavior of the extended primitives. Indeed, telling a dense set amounts to telling atomically the t i (m i )'s of a tuple defined above. Asking or getting a dense set requires to check that a tuple of D([t 1 , · · · ,t p ](m)) is present on the considered store. For the negative ask, the requirement is that none of the tuple is present. For the ease of writing and to make this latter concept clear, we introduce the following concept of intersection. Definition 6. Let m be a positive integer, L = [t 1 , · · · ,t p ] be a set of tokens and σ a store. We define D(L(m)) ⊓ σ as the following set of tuples of dense tokens : From an implementation point of view, it is worth observing that one may give a syntactical characterization of the emptyness of such an intersection. Definition 7. Given a store σ and a dense set L(m), with L = [t 1 , · · · ,t p ], we denote by Max(σ , L(m)) the tuple (t 1 (m 1 ), . . . ,t p (m p )) where the m i 's denote the number of occurrences of t i in σ . Moreover, we denote by SMax(σ , L(m)) the sum m 1 + · · · + m p It is easy to establish the following proposition. We are now in a position to specify the language extension handling dense sets of tokens.

Definition 8.
Define the set of dense sets primitives T dbd as the set of primitives T dbd generated by the following grammar: where L(m) represents a dense set of tokens.
The transition steps for these primitives are defined in figure 3. As suggested above, rule (T dbd ) specifies that telling a dense set L(m) of tokens amounts to atomically add the multiple occurrences t i (m i )'s of the tokens of a tuple of the distribution of m over L. Note that the selected tuple is chosen non-deterministically, which gives to a tell primitive a non-deterministic behavior as opposed to the tell primitives of Bach and Dense Bach. Rule (A dbd ) states that asking for the dense set L(m) amounts to testing that a tuple of the distribution of m over L is in the store, which is technically stated through the non-emptyness of the intersection of the distribution and the store. Rule (G dbd ) requires that the tokens of the tuples are removed in the considered multiplicity. Finally, rule (N dbd ) specifies that negatively asking L(m) succeeds if m is strictly positive and no tuple of the distribution of m over L is present on the current store.

Languages
We are now in a position to define the languages we shall consider. The statements of these languages, also called agents, are defined from the tell, ask, get and nask primitives by possibly combining them by the classical choice operator +, used among others in CCS, parallel operator (denoted by the || symbol) and the sequential operator (denoted by the ; symbol). The formal definition is as follows.

Definition 9.
Define the Bach language L B as the set of agents A generated by the following grammar: where T represents a token-based primitive. Define the Dense Bach language L DB similarly but by taking dense token-based primitives T d : Define the Dense Bach with distributed Density language L DBD similarly but by taking lists of tokenbased primitives T dbd : Subsequently, we shall consider sublanguages formed similarly but by considering only subsets of these primitives. In that case, if H denotes such a subset, then we shall write the induced sublanguages as L (H ), L DB (H ), and L DBD (H ) respectively. Note that for the latter sublanguages, the tell, ask, nask and get primitives are associated with the basic pairs described above.

Transition system
To study the expressiveness of the languages, a semantics needs to be defined. As suggested in the previous subsections, we shall use an operational one, based on transition systems. For each transition system, the configuration consists of agents (summarizing the current state of the agents running on the store) and a multi-set of tokens (denoting the current state of the store). In order to express the termination of the computation of an agent, we extend the set of agents by adding a special terminating symbol E that can be seen as a completely computed agent. For uniformity purpose, we abuse the language by qualifying E as an agent. To meet the intuition, we shall always rewrite agents of the form (E; A), (E || A) and (A || E) as A. This is technically achieved by defining the extended sets of agents as L B ∪ {E}, L DB ∪ {E} or L DBD ∪ {E} and by justifying the simplifications by imposing a bimonoid structure.
The rules for the primitives of the languages have been given in Figures 1 to 3. Figure 4 details the usual rules for sequential composition, parallel composition, interpreted in an interleaving fashion, and CCS-like choice.

Observables and operational semantics
We are now in a position to define what we want to observe from the computations. Following previous work by some of the authors (see eg [7,8,[13][14][15]), we shall actually take an operational semantics recording the final state of the computations, this being understood as the final store coupled to a mark indicating whether the considered computation is successful or not. Such marks are respectively denoted as δ + (for the successful computations) and δ − (for failed computations).

Comparison of Dense Bach and Dense Bach with Distributed Density
This section focusses on the comparison between the Dense Bach language and the newly introduced Dense Bach with Distrbuted Density language.

Modular embedding
A natural way to compare the expressive power of two languages is to determine whether all programs written in one language can be easily and equivalently translated into the other language, where equivalent is intended in the sense of conserving the same observable behaviors. According to this intuition, Shapiro introduced in [17] a first notion of embedding as follows. Consider two languages L and L ′ . Assume given the semantics mappings This basic notion of embedding turns out however to be too weak since, for instance, the above equation is satisfied by any pair of Turing-complete languages. de Boer and Palamidessi hence proposed in [1] to add three constraints on the coder C and on the decoder D c in order to obtain a notion of modular embedding usable for concurrent languages: 1. D c should be defined in an element-wise way with respect to O s , namely for some appropriate 2. the coder C should be defined in a compositional way with respect to the sequential, parallel and choice operators: 3. the embedding should preserve the behavior of the original processes with respect to deadlock, failure and success (termination invariance): where tm and tm' extract the termination information from the observables of L and L ′ , respectively.
An embedding is then called modular if it satisfies properties P 1 , P 2 , and P 3 . The existence of a modular embedding from L ′ into L is subsequently denoted by L ′ ≤ L . It is easy to prove that ≤ is a pre-order relation. Moreover if L ′ ⊆ L then L ′ ≤ L that is, any language embeds all its sublanguages. This property descends immediately from the definition of embedding, by setting C and D c equal to the identity function.

Formal propositions and proofs
Let us now turn to the formal proofs. As a first result, thanks to the fact that any language contains its sublanguages, a number of modular embeddings are directly established. In subsequent proofs, this is referred to by language inclusion. Proposition 1. L DBD ( ψ) ≤ L DBD ( χ), for any subsets of ψ, χ of primitives such that ψ ⊆ χ.
A second observation is that Dense Bach primitives are deduced from the primitives of Dense Bach with Distributed Density by taking dense sets with only one token, the density being the same. As a result Dense Bach sublanguages are embedded in the corresponding Dense Bach with Distributed Density sublanguages. Proposition 2. L DB ( χ) ≤ L DBD ( χ), for any subset of χ of primitives.
As a result of the expressiveness hierarchy of [12], it also comes that both languages L DB (ask,tell) and L DB (nask,tell) are strictly more expressive than L DBD (tell) since both have been established strictly more expressive than L DB (tell).
Let us now compare L DB (ask,tell) with its distributed dense counterpart.  (2)).
Let us prove that its coder is empty, which is absurd since, by definition 9, it should contain at least one primitive. To that end, one may assume that C (AB) is in normal form [6] and thus is written as tell(t 1 ); A 1 + · · · + tell(t p ); A p + ask(u 1 ); B 1 + · · · + ask(u q ); B q , where t i and u j denote the token t i and u j associated to a density. In this expression, we will establish that there is no alternative guarded by a tell(t i ) operation, and no alternative guarded by a ask(u j ) operation either, in which case C (AB) is empty. Let us first establish by contradiction that there is no alternative guarded by a tell(t i ) operation. Assume there is one, say guarded by tell(t i ). Secondly we establish that there is also no alternative guarded by an ask(u j ) operation. To that end, let us first consider two auxiliary computations: as O(tell([a](1))) = ({a}, δ + ), any computation of C (tell([a](1))) starting in the empty store succeeds. Let C (tell([a](1)))| / 0 → · · · → E|{a 1 , . . . , a m } be such a computation. Similarly, let C (tell([b](1)))| / 0 → · · · → E|{b 1 , . . . , b n } be one computation of C (tell([b](1))). The proof of the claim proceeds in two steps. First let us prove that none of the u i 's belong to {a 1 , . . . , a m }. By contradiction, assume that u i = a k for some k and that d is the density associated to u i , namely, u i = u i (d). Let us observe that, since it is in L DB (ask,tell), the considered computation of C (tell([a](1))) can be repeated sequentially, as many times as needed. As a result, by using A d to denote the sequential composition of d instances of A, the sequence  (1)); AB has only one successful computation. As a conclusion, C (AB) is equivalent to an empty statement, which is absurd by definition 9.
Proof. On the one hand, L DB (nask,tell) ≤ L DBD (nask,tell) holds by proposition 2. On the other hand, L DBD (nask,tell) ≤ L DB (nask,tell) is proved by contradiction, assuming the existence of a coder C . The proof proceeds as in proposition 4 but this time by exploiting the inability of L DB (nask,tell) to atomically test the absence of two distinct tokens a and b.
L DBD (nask,tell) and L DB (ask,tell) are not comparable with each other, as well as L DBD (ask,tell) with regards to L DB (nask,tell).
L DBD (nask,tell) and L DBD (ask,tell) are not comparable with each other, as well as L DBD (nask,tell) with regards to L DB (ask,nask,tell).
Symmetrically, L DB (get,tell) and L DBD (ask,tell) are not comparable with each other, as L DB (get,tell) and L DBD (nask,tell) are not comparable with each other.
Let us now prove that L DB (get,tell) is not comparable with L DBD (ask,nask,tell).
Let us now establish that L DB (get,tell) is strictly less expressive than L DBD (get,tell).  2)).
In order to use once more the reasoning of proposition 8(ii), we now prove that L DBD (ask,tell) is not comparable with L DB (nask,get,tell).

Proposition 12.
(i) L DBD (ask,tell) ≤ L DB (nask,get,tell) (ii) L DB (nask,get,tell) ≤ L DBD (ask,tell) Proof. (i) The proof proceeds as in proposition 8(ii), by constructing a successful coded computation for the same failing agent ask ([a, b](2)) with the alternatives guarded by a nask primitive of the normal form of the coded version treated as the alternatives guarded by a tell primitive. (ii) Otherwise L DB (nask,tell) ≤ L DBD (ask,tell) which contradicts proposition 6(iv).
Let us now establish that L DBD (nask,tell) and L DB (ask,nask,tell) are strictly less expressive than L DBD (ask,nask,tell).
(ii) Let us thus proceed by contradiction by assuming the existence of a coder C from L DBD (ask,nask,tell) to L DB (ask,nask,tell). Let n be the cumulative occurrences of tokens in nask primitives of C (tell([a](1))).
As C (tell([a](1))) has only successful computations, let S a be the store resulting from one of them. Moreover, as a matter of notation, let the construction A ||q denote the parallel composition of q copies of A. As (tell([b](1))) ||(n+2) ; tell([a](1))) succeeds as well, let S ′ b denote the store resulting from one successful computation of its coding. Consider finally ABs = ask ([a, b](n + 4)) with the intuitive aim of requesting one a with n + 3 copies of b. Consider C (ABs) in its normal form: tell(t 1 ) ; A 1 + · · · + tell(t p ) ; A p + ask(u 1 ) ; B 1 + · · · + ask(u q ) ; B q + nask(v 1 ) ; C 1 + · · · + nask(v r ) ; C r As in proposition 5(ii), it is possible to establish that there are no alternatives guarded by tell(t i ) and nask(v j ) primitives.
Let us prove that {u 1 , · · · , u q } ∩ (S a ∪ S ′ b ) = / 0. This is done in two steps by establishing that (1) {u 1 , · · · , u q } ∩ S a = / 0, and that (2) {u 1 , · · · , u q } ∩ S ′ b = / 0. First let us prove that {u 1 , · · · , u q } ∩ S a = / 0. Assume u i ∈ S a and let d be the density associated to u i , namely, u i = u i (d). Let us observe that each step of the considered computation of C (tell([a](1))) can be repeated in turn, in as many parallel occurences of it as needed, so that is a valid computation prefix of C (tell([a](1)) ||q ; ABs), which can only be continued by failing suffixes. However P induces the following computation prefix P ′ for C (tell([a](1)) ||q ; (ABs+tell([a](1)))) which admits only successful computations: leading to the contradiction. Secondly, the proof that {u 1 , · · · , u q } ∩ S ′ b = / 0 is established similarly by considering S ′ b instead of S a and tell ([b](1)) instead of tell([a](1)).
(ii) The proof proceeds by contradiction, similarly to the proofs of L DBD (nask,tell) ≤ L DB (ask,nask,tell) of proposition 7(iv), which itself extends that of L DBD (nask,tell) ≤ L DB (nask,tell) of proposition 5(ii).
L DBD (get,tell) is strictly less expressive than L DBD (nask,get,tell). (1))) starting on the empty store succeeds. Similarly, any computation of C (nask([t](1))) starting on the empty store succeeds. Moreover, as C (nask([t](1))) is composed of get and tell primitives only, for any store σ , C (nask([t](1))) admits at least one successful computation starting on σ . It follows that any computation of C (tell([t](1))) starting on the empty store can be continued by a (successful) computation of C (nask([t](1))), which leads to the announced contradiction.
Finally, L DB (ask,nask,get,tell) can be proved strictly less expressive than L DBD (ask,nask,get,tell).

Conclusion
This paper is written in the continuity of our previous research on the expressiveness of Linda-like languages. It has presented an extension of our Dense Bach language, that had promoted the notions of density and dense tokens. The new language, called Dense Bach with Distributed Density, proposes to distribute the density on a finite list of tokens manipulated by the four classical primitives of the language. Technically this is achieved by associating a positive number, called density, to a finite list of tokens and to distribute this density among the tokens of the list. Our work builds upon previous work by some of the authors [7,8,[13][14][15]. We have essentially followed the same lines and in particular have used de Boer and Palamidessi's notion of modular embedding to compare the families of sublanguages of Dense Bach and Dense Bach with Distributed Density. Accordingly, we have established a gain of expressivity, namely that Dense Bach with Distributed Density is strictly more expressive than Dense Bach and, consequently, in view of the results of [12], strictly more expressive than the Bach and Linda languages.
Our work has similarities but also differences with several work on the expressiveness of Lindalike languages. Compared to [19] and [20], it is worth observing that a different comparison criteria is used to compare the expressiveness of languages. Indeed, in these pieces of work, the comparison is performed on (i) the compositionality of the encoding with respect to parallel composition, (ii) the preservation of divergence and deadlock, and (iii) a symmetry condition. Moreover, as will be observed by the careful reader, we have taken a more liberal view with respect to the preservation of termination marks in requiring these preservations on the store resulting from the execution from the empty store of the coded versions of the considered agents and not on the same store. In particular, these ending stores are not required to be of the form σ ∪ σ (where ∪ denotes multi-set union) if this is so for the stores resulting from the agents themselves.
In [2], nine variants of the L (ask,nask,get,tell) language are studied. They are obtained by varying both the nature of the shared data space and its structure. Rephrased in the setting of [1], this amounts to considering different operational semantics. In contrast, in our work we fix an operational semantics and compare different languages on the basis of this semantics. In [11], a process algebraic treatment of a family of Linda-like concurrent languages is presented. Again, different semantics are considered whereas we have sticked to one semantics and have compared languages on this basis.
In [10], a study of the absolute expressive power of different variants of Linda-like languages has been made, whereas we study the relative expressive power of different variants of such languages (using modular embedding as a yard-stick and the ordered interpretation of tell).
It is worth observing that [2,10,11,19,20] do not deal with a notion of density attached to tuples. In contrast, [3] and [4] decorate tuples with an extra field in order to investigate how probabilities and priorities can be introduced in the Linda coordination model. Different expressiveness results are established in [3] but on an absolute level with respect to Turing expressiveness and the possibility to encode the Leader Election Problem. Our work contrasts in several aspects. First, we have established relative expressiveness results by comparing the sublanguages of two families. Moreover, some of these sublanguages incorporate the nask primitives, which strictly increases the expressiveness. Finally, the introduction of density resembles but is not identical to the association of weights to tuples. Indeed, in contrast to [3,4] we do not modify the tuples on the store and do not modify the matching function so as to retrieve the tuple with the highest weight. In contrast, we modify the tuple primitives so as to be able to atomically put several occurrences of a tuple on the store and check for the presence or absence of a number of occurrences. We have also introduced a distribution of a density among the tokens of a set, which results in adding a new non-deterministic behavior to the tell, ask and get primitives. As can be appreciated by the reader through the comparison of Bach, Dense Bach and Dense Bach with Distributed Density, this facility of handling atomically several occurrences produces a real increase of expressiveness. One may however naturally think of encoding the number of occurrences of a tuple as an additional weight-like parameter. It is nevertheless not clear how our primitives tackling at once several occurrences can be rephrased in Linda-like primitives and how the induced encoding would still fulfills the requirements of modularity. Moreover, in contrast to Linda-like language, due to the nondeterminism of the get and tell primitives, it is not clear how to code ask primitives by get and tell ones in our distributed density framework. This will be the subject for future research.
In [18], Viroli and Casadei propose a stochastic extension of the Linda framework, with a notion of tuple concentration, similar to the weight of [3] and [4] and our notion of density. The syntax of this tuple space is modeled by means of a calculus, with an operational semantics given as an hybrid CTMC/DTMC model. This operational semantics describes the behavior of tell, ask and get like primitives but does not consider a nask like primitive. Moreover, no expressiveness results are established and there is no counterpart for non-determinism arising from the distribution of density on tokens.
These three last pieces of work tackle probabilistic extensions of Linda-like languages. As a further and natural step in our research, we aim at studying how our notion of density can be the basis of such probabilistic extensions. As our work also relies on the possibility to atomically put several occurrences of tokens and test for their presence or absence, we will also examine in future work how Dense Bach with Distributed Density compares with the Gamma language.