Computing Embeddings of Directed Bigraphs

Abstract

Directed bigraphs are a meta-model which generalises Milner’s bigraphs by taking into account the request flow between controls and names. A key problem about these bigraphs is that of bigraph embedding, i.e., finding the embeddings of a bigraph inside a larger one. We present an algorithm for computing embeddings of directed bigraphs, via a reduction to a constraint satisfaction problem. We prove soundness and completeness of this algorithm, and provide an implementation in jLibBig, a general Java library for manipulating bigraphical reactive systems, together with some experimental results.

Introduction

Bigraphical Reactive Systems (BRSs) are a family of graph-based formalisms introduced as a meta-model for distributed, mobile systems [17, 22, 25]. In this approach, system configurations are represented by bigraphs, graph-like data structures capable of describing at once both the locations and the logical connections of (possibly nested) components. The dynamics of a system is defined by means of a set of graph rewriting rules, which can replace and change components’ positions and connections. BRSs have been successfully applied to the formalization of a wide spectrum of domain-specific models, including context-aware systems, web-service orchestration languages [4, 5, 20, 28]. BRSs are appealing because they provide a range of general results and tools, which can be readily instantiated with the specific model under scrutiny: libraries for bigraph manipulation (e.g., DBtk [1] and jLibBig [23, 24]), simulation tools [10, 19, 21], graphical editors [9], model checkers [27], modular composition [26], stochastic extensions [18], etc.

Along this line, [13, 14] introduced directed bigraphs, a strict generalization of Milner’s bigraphs where the link graph is directed (see Fig. 1). This variant is very suited for reasoning about dependencies and request flows between components, such as those found in client-server or producer-consumer scenarios. In fact, they have been used to design formal models of security protocols [12], molecular biology [2], access control [15], container-based systems [5], etc.

Fig. 1.

An example of directed bigraph and its place and link graphs [15].

A key notion at the core of these results and tools is that of bigraph embedding. Informally, an embedding is a structure preserving map from a bigraph (called guest) to another one (called host), akin a subgraph isomorphism. Finding such embeddings is a difficult problem; in fact, the sole embedding of place graphs has been proved to be NP-complete [3]. Several algorithms have been proposed in literature for bigraphs with undirected links (see e.g. [7, 11, 23, 29, 30]), but there is no embedding algorithm for the more general case of directed bigraphs, yet.

In this work, we propose an algorithm for computing embedding of directed bigraphs (which subsume traditional ones), laying the theoretical and technical foundations for bringing directed bigraphs to tools like the ones listed above.

More precisely, in Sect. 2 we first introduce directed bigraphs and bigraphic reactive systems, generalizing [5, 13]. Then, the notion of directed bigraph embedding is defined in Sect. 3. In Sect. 4 we present a reduction of the embedding problem for directed bigraphs to a constraint satisfaction problem (CSP) and show that it provides a sound and complete algorithm for computing embeddings. This reduction extends our previous (unpublished) work [23] on the embedding problem for undirected bigraphs. We have implemented this algorithm as an extension of jLibBig [24], a general Java library for BRSs; this implementation and some experimental results are reported in Sect. 5. Finally, some conclusions and directions for future work are drawn in Sect. 6.

Reactive Systems on Directed Bigraphs

In this section we introduce a conservative extension of the notions of directed link graphs and bigraphs, and directed bigraphical reactive systems, originally defined in [13, 14].

Directed Bigraphs

Definition 1 (Polarized interface)

A polarized interface X is a pair , where and are sets of names s.t. ; the two sets are called downward and upward interfaces respectively.

Definition 2 (Polarized signature)

A signature is a pair , where is the set of controls, and is a map assigning to each control its polarized arity, that is, a pair where n, m are the numbers of positive and negative ports of the control, respectively.

We define as shorthand for the positive and negative ports of controls: , .

The main difference between this definition and that from [13] is that we allow also for inward ports in controls, whereas in [13], like in [25], controls have only outward ports. This turns up also in the definition of points and handles. The addition of negative ports enables us to represent more faithfully the dependencies between processes, entities and components, according to the micro-services paradigm.

Definition 3 (Directed Link Graph)

A directed link graph is a quadruple where X, Y, V, E and ctrl are defined as before, while the link map is defined as where

with the following additional constraints:

1

2

The elements of Pnt(A) are called the points of A; the elements of Lnk(A) are called the handles of A.

The constraint (1) means that if there is an upward inner name connected to a downward inner name, then nothing else can be connected to the latter; constraint (2) is similar, on the outer interface. Together, these requirements guarantee that composition of link graphs (along the correct interfaces) is well defined.

Direct link graphs are graphically depicted similarly to ordinary link graphs, with the difference that edges are represented as vertices of the graph and not as hyper-arcs connecting points and names.

Directed bigraphs are composed by a directed link graph and a place graph. Since the definition of place graph is the same as for pure bigraphs, we will omit it and refer the interested reader to [25].

Definition 4 (Directed Bigraph)

An interface is composed by a finite ordinal m, called the width, and by a directed interface .

Let and be two interfaces; a directed bigraph with signature from I to O is a tuple where

• I and O are the inner and outer interfaces;

• V and E are the sets of nodes and edges;

• ctrl, prnt, link are the control, parent and link maps;

such that is a directed link graph and is a place graph, that is, the map is acyclic. The bigraph G is denoted also as .

Definition 5 (Composition and identities)

• The composition of two place graphs and , is defined in the same way as pure bigraphs (i.e., suitable grafting of forests);

• If and are two link graphs, their composition is the link graph such that , , , and is defined as follows:

  

  where is . The identity link graph at X is .
• If and are two bigraphs, their composite is

  

  and the identity bigraph at is .

Definition 6 (Juxtaposition)

• For place graphs, the juxtaposition of two interfaces and is ; the unit is 0. If are disjoint place graphs (with ), their juxtaposition is defined as for pure bigraphs;

• For link graphs, the juxtaposition of two (directed) link graph interfaces and is . If are two link graphs (with ), their juxtaposition is

  
• For bigraphs, the juxtaposition of two interfaces (with ) is (the unit is ). If are two bigraphs (with ), their juxtaposition is

  

Polarized interfaces and directed bigraphs over a given signature form a monoidal category .

Milner’s pure bigraphs [25] correspond precisely to directed bigraphs with positive interfaces only and over signatures with only positive ports. We observe also that the introduction of negative ports is more important than adding directions to interfaces: directed bigraphs as per [13] can be obtained as a traced category over the category of pure bigraphs, while we cannot properly represent controls with negative ports using those with positive ports only.

Reactive Systems over Directed Bigraphs

In order to define reactive systems over bigraphs, we need to define how a parametric reaction rule (i.e., a pair of “redex-reactum” bigraphs) can be instantiated. Essentially, in the application of the rule, the “sites” of the reactum must be filled with the parameters appearing in the redex. This relation can be expressed by specifying an instantiation map in the rule.

Definition 7 (Instantiation map)

An instantiation map is a pair where

• is a function which maps sites of the reactum to sites of the redex; for each , it determines that the j-th site of the reactum is filled with the -th parameter of the redex.

• is a wiring (i.e., a link graph without nodes nor edges), which is responsible for mapping names of the redex to names of the reactum. This can be described as a pair of functions where and .

We can now define the dynamics of directed bigraphs, starting with the formal definition of parametric reaction rules.

Definition 8 (Parametric reaction rule)

A parametric reaction rule for bigraphs is a triple of the form where R is the parametric redex, the parametric reactum and is an instantiation map.

We can now define the key notion of reactive systems over directed bigraphs, which is a generalization of that in [14, 25]. Let be the set of agents (i.e., bigraphs with no inner names nor sites) over a signature .

Definition 9 (DBRS)

A directed bigraphical reactive system is defined by a signature and a set of rewriting rules.

A DBRS induces a rewriting relation according to the following rule:

where and are called wiring maps and are defined as follows:

The difference with respect to the previous versions of BRS is that now links can descend from the redex (and reactum) into the parameters, as it is evident from the fact that redexes and reactums in rules may have generic inner interfaces (I and ). This is very useful for representing a request flow which goes “downwards”, e.g. connecting a port of a control in the redex to a port of an inner component (think of, e.g., a linked library).

However, this poses some issues when the rules are not linear. If any of ’s is cancelled by the rewriting, the controls in it disappear as well, and we may be not able to connect some name descending from or anymore. More formally, this means that the map can be defined only if for every there are j, y such that . We can have two cases:

1. for some x, there are no such j, y. This means that is not defined and hence the rule cannot be applied.

2. for each x, there are one or more pairs (j, y) such that . This means that for a given source agent decomposition, there can be several ways to define , each yielding a different application of the same rule.

Overall, the presence of downward names in parameters adds a new degree of non-determinism to Directed BRSs, with respect to previous versions of BRSs.

Directed Bigraph Embeddings

As we have seen in the previous section, to execute or simulate a BRS it is necessary to solve the bigraph matching problem, that is, finding the occurrences of a redex R within a given bigraph A. More formally, this translates to finding and such that . C and D are called context and parameter, respectively.

If we abstract from the decomposition of the agent A in context, redex and parameter we can see how the matching problem is related to the subgraph isomorphism problem. Therefore, in this section we define the notions of directed bigraph embedding. The following definitions are taken from [16], modified to suit the definition of directed bigraphs.

Directed Link Graph. Intuitively an embedding of link graphs is a structure preserving map from one link graph (the guest) to another (the host). As one would expect from a graph embedding, this map contains a pair of injections: one for the nodes and one for the edges (i.e., a support translation). The remaining of the embedding map specifies how names of the inner and outer interfaces should be mapped into the host link graph. Outer names can be mapped to any link; here injectivity is not required since a context can alias outer names. Dually, inner names can be mapped to hyper-edges linking sets of points in the host link graph and such that every point is contained in at most one of these sets.

Definition 10 (Directed link graph embedding)

Let and be two directed link graphs. A directed link graph embedding is a map , assigning nodes, edges, inner and outer names with the following constraints:

(L1)

and are injective;

(L2)

;

(L3)

defined as follows

(L4)

is a partial map s.t.:

(L5a)

;

(L5b)

;

(L6a)

;

(L6b)

;

(L7)

.

where and is .

The first three conditions are on the single sub-maps of the embedding. Conditions (L5a) and (L5b) ensures that no components (except for outer names) are identified; condition (L6a) imposes that points connected by the image of an edge are all covered. Finally, conditions (L2), (L6b) and (L7) ensure that the guest structure is preserved i.e. node controls and point linkings are preserved.

Place Graph. Like link graph embeddings, place graph embeddings are just a structure preserving injective map from nodes along with suitable maps for the inner and outer interfaces. In particular, a site is mapped to the set of sites and nodes that are “put under it” and a root is mapped to the host root or node that is “put over it” splitting the host place graphs in three parts: the guest image, the context and the parameter (which are above and below the guest image).

Definition 11

(Place graph embedding [16, Def 7.5.4]). Let and be two place graphs. A place graph embedding is a map (assigning nodes, sites and roots respectively) such that:

(P1)

is injective;

(P2)

is fully injective;

(P3)

in an arbitrary map;

(P4)

and ;

(P5)

;

(P6)

;

(P7)

;

(P8)

;

where , , and .

These conditions follow the structure of Definition 10, the main difference is (P5) which states that the image of a root cannot be the descendant of the image of another. Conditions (P1), (P2) and (P3) are on the three sub-maps composing the embedding; (P4) and (P5) ensure that no components are identified; (P6) imposes surjectivity on children and the last two conditions require the guest structure to be preserved by the embedding.

Directed Bigraph. Finally, a directed bigraph embedding can be defined as a pair composed by an directed link graph embedding and a place graph embedding, with a consistent interplay of these two structures. The interplay is captured by two additional conditions ensuring that points (resp. handles) in the image of guest upward (resp. downward) inner names reside in some parameter defined by the place graph embedding (i.e. descends from the image of a site).

Definition 12 (Directed bigraph embedding)

Let and be two directed bigraphs. A directed bigraph embedding is a map given by a place graph embedding and a link graph embedding subject to the following constraints:

(B1)

;

(B2)

.

Implementing the Embedding Problem in CSP

In this Section we present a constraint satisfaction problem that models the directed bigraph embedding problem. The encoding is based solely on integer linear constraints and is proven to be sound and complete.

Initially, we present the encoding for the directed link graph embedding problem and for the place graph embedding problem. Then we combine them providing some additional “gluing constraints” to ensure the consistency of the two sub-problems. The resulting encoding contains 37 constraint families (reflecting the complexity of the problem definition, see Sect. 3); hence we take advantage of the orthogonality of link and place structures for the sake of both exposition and adequacy proofs. We observe that the overall number of variables and constraints produced by the encoding is polynomially bounded with respect to the size of the involved bigraphs, i.e., the number of nodes and edges.

Directed Link Graphs

Let us fix the guest and host bigraphs and . We characterize the embeddings of G into H as the solutions of a suitable multi-flux problem which we denote as DLGE[G, H]. The main idea is to see the host points (i.e. positive ports, upward inner names and downward outer names) as sources, and the handles (i.e. edges, negative ports, upward outer names and downward inner names) as sinks (see Fig. 2). Each point outputs a flux unit and each handle inputs one unit for each point it links. Units flow towards each point handle following H edges and optionally taking a “detour” along the linking structure of the guest G (provided that some conditions about structure preservation are met). The formal definition of the flux problem is in Fig. 3.

Fig. 2.

Schema of the multi-flux network encoding.

Fig. 3.

Constraints of DLGE[G, H].

The flux network reflects the linking structure and contains an edge connecting each point to its handle; these edges have an integer capacity limited to 1 and are represented by the variables defined in (4). The remaining edges of the network are organised in two complete biparted graphs: one between guest and host handles and one between guest and host points. Edges of the first sub-network are described by the variables in (3) and their capacity is bounded by the number of points linked by the host handle since this is the maximum acceptable flux and corresponds to the case where each point passes through the same hyper-edge of the guest link graph. Edges of the second sub-network are described by the variables in (5) and, like the first group of links, have their capacity limited to 1; to be precise, some of these variables will never assume a value different from 0 because guest points can receive flux from anything but the host ports (as expressed by constraint (11)). Edges for the link structure of the guest are presented implicitly in the flux preservation constraints (see constraint (9)). In order to fulfil the injectivity conditions of link embeddings, some additional flux variables (whereas the previous are network variables) are defined by (6). These are used to keep track and separate each flux on the bases of the points handle.

The constraint families (7) and (8) define the outgoing and ingoing flux of host points and handles respectively. The former has to send exactly one unit considering every edge they are involved with and the latter receive one unit for each of their point regardless if this unit comes from the point directly or from a handle of the guest.

The linking structure of the guest graph is encoded by the constraint family (9) which states that flux is preserved while passing through the guest i.e. the output of each handle has to match the overall input of the points it connects.

Constraints (10), (11), (20), (21), (22) and (23) shape the flux in the sub-network linking guest and host points. Specifically, (10) requires that each point from the guest receives at most one unit; this is needed when we want to be able to embed a redex where some points (e.g. upward inner names) would not match with an entity of the agent and (those points) would be deleted anyway when composing the resulting agent back. Constraints (11), (20) and (21) disable edges between guest ports and host inner names, between mismatching ports of matching nodes and between ports of mismatching nodes. Constraint (23) ensures that ascending inner names or descending outer names of the redex are not matched with positive ports of the agent. Finally, the flux of ports of the same node has to act compactly, as expressed by (22): if there is flux between the i-th ports of two nodes, then there should be flux between every other ports.

Constraints (12), (13) and (14) relate flux and network variables ensuring that the formers assume a true value if, and only, if there is actual flux between the corresponding guest and host handles. In particular, (13) propagates the information about the absence of flux between handles disabling the sub-network linking handles points and, vice versa, (14) propagates the information in the other way disabling flux between handles if there is no flux between their points.

The remaining constraints prevent fluxes from mixing. Constraint (15) requires guest handles to send their output to exactly one destination thus rendering the sub-network between handles a function assigning guest handles to host handles. This mapping is subject to some additional conditions when edges are involved: (18) and (19) ensure that the edges are injectively mapped to edges only, (17) forbids host outer names to receive flux from an edge and an outer name at the same time. Finally, (16) states that the output of host points cannot bypass the guest if there is flux between its handle and an edge from the guest.

Adequacy. Let be a solution of DLGE[G, H]. The corresponding link graph embedding is defined as follows:

where

It is easy to check that these components of are well-defined and compliant with Definition 10.

On the other way around, let be a link graph embedding. The corresponding solution of DLGE[G, H] is defined as follows:

Every constraint of DLGE[G, H] is satisfied by the solution just defined.

The constraint satisfaction problem in Fig. 3 is sound and complete with respect to the directed link graph embedding problem given in Definition 10.

Proposition 1 (Adequacy of DLGE)

For any two concrete directed link graphs G and H, there is a bijective correspondence between the directed link graph embeddings of G into H and the solutions of DLGE[G, H].

Place Graphs

Let us fix the guest and host place graphs: and . We characterize the embeddings of G into H as the solutions of the constraint satisfaction problem in Fig. 4. The problem is a direct encoding of Definition 11 as a matching problem presented, as usual, as a bipartite graph. Sites, nodes and roots of the two place graphs are represented as nodes and partitioned into the guest and the host ones. For convenience of exposition, the graph is complete.

Fig. 4.

Constraints of PGE[G, H].

Edges are modelled by the boolean variables defined in (24); these are the only variables used by the problem. So far, a solution is nothing more than a relation between the components of guest and host containing only those pairs connected by an edge assigned a non-zero value. To capture exactly those assignments that are actual place graph embeddings some conditions have to be imposed.

Constraints (25) and (26) prevent roots and sites from the host to be matched with nodes or sites and nodes or roots respectively. (27) disables matching between nodes decorated with different controls. Constraint (28) prevents any matching for host nodes under a passive context (i.e. have an ancestor labelled with a passive control). (29) propagates the matching along the parent map from children to parents. Constraints (30) and (31) ensure that the matching is a function when restricted to guest nodes and roots (the codomain restriction follows by (25) and (26)). (32) says that if a node from the host cannot be matched with a root or a node/site from the guest at the same time; moreover, if the host node is matched with a node then it cannot be matched to anything else.

The remaining constraints are the counterpart of (29) and propagate matchings from parents to children. (33) applies to matchings between nodes and says that if parents are matched, then children from the host node are covered by children from the guest node. In particular, the matching is a perfect assignment when restricted to guest children that are nodes (because of (32)) and is a surjection on those that are sites. (34) imposes a similar condition on matchings between guest roots and host nodes. Specifically, it says that the matching has to cover child nodes from the guest (moreover, it is injective on them) leaving child sites to match whatever remains ranging from nothing to all unmatched children. Finally, (35) prevents matching from happening inside a parameter.

Adequacy. Let be a solution of PGE[G, H]. The corresponding place graph embedding is defined as follows:

These components of are well-defined and compliant with Definition 11.

On the opposite direction, let be a place graph embedding. The corresponding solution of PGE[G, H] is defined as aside. It is easy to check that every constraint of PGE[G, H] is satisfied by this solution. Hence, the constraint satisfaction problem in Fig. 4 is sound and complete with respect to the place graph embedding problem (Definition 11).

Proposition 2 (Adequacy of PGE)

For any two concrete place graphs G and H, there is a bijective correspondence between the place graph embeddings of G into H and the solutions of PGE[G, H].

Bigraphs

Let and be two bigraphs. By taking advantage of the orthogonality of the link and place structures we can define the constraint satisfaction problem capturing bigraph embeddings by simply composing the constraints given above for the link and place graph embeddings and by adding four consistency constraints to relate the solutions of the two problems. These additional constraint families are reported in Fig. 5. The families (36) and (37) ensure that solutions for DLGE[G, H] and PGE[ G ,  H ] agree on nodes since the map has to be shared by the corresponding link and place embeddings. The families (38) and (39) respectively, ensure that positive ports (negative ports resp.) are in the same image as upward inner names (downward inner names resp.) only if their node is part of the parameter i.e. only if it is matched to a site from the guest or it descends from a node that is so.

Fig. 5.

Constraints of DBGE[G, H].

Conditions (38) and (39) correspond exactly to (B1) and (B2). It thus follows from Propositions 1 and 2 that the CSP defined by Figs. 3 to 5 is sound and complete with respect to the bigraph embedding problem given in Definition 12.

Theorem 1 (Adequacy of BGE)

For any two concrete bigraphs G and H, there is a bijective correspondence between the bigraph embeddings of G into H and the solutions of DBGE[G, H].

Experimental Results

The reduction algorithm presented in the previous section has been successfully integrated into jLibBig, an extensible Java library for manipulating bigraphs and bigraphical reactive systems which can be used for implementing a wide range of tools and it can be adapted to support several extensions of bigraphs [24].

The proposed algorithm is implemented by extending the data structures and the models for pure bigraphs to suit our definition of directed bigraphs.

In this section we test our implementation by simulating a system in which we want to track the position and the movements of a fleet of vehicles inside a territory divided in “zones”, which are accessible via “roads”. The rewriting rule in question and an example agent can be found in Fig. 6.

Fig. 6.

Rewriting rule (left) and example of an agent (right) for the test cases.

We evaluate the running time of the different components of our algorithm: model construction, CSP resolution, building of the actual embedding and execution of the rewriting rule. Moreover, we want to evaluate how these performances scale while increasing the size of the agent. The parameters used to build the tests are: number of zones, number of cars and “connectivity degree”. The last parameter is a number between 1 and 100 representing the probability of the existence of a connection between two nodes; a value of 100 means that every node is connected to all its neighbours.

We consider the following kinds of tests:

1. varying number of zones, with fixed number of cars and connectivity degree;

2. varying connectivity degree, with fixed numbers of zones and cars.

Each test case is made up of four groups of instances, where for each group we choose an increasing value for their fixed parameters. For each group we choose ten values for its variable parameter. The instances generation works as follows: for each test case and for each group of that particular test case we generate ten random instances for each combination of the values of the fixed parameters and the variable one. We then take the average of the running times of those ten random instances. At the end of the process, for each group we have tested 100 instances, 10 for each value of the variable parameter, so 400 instances for each test case and 1200 in total.

All tests have been performed on an Intel Core i7-4710HQ (4 cores at 3.5 GHz), 8 GB of RAM running on ArchLinux with kernel 5.5.2 and using OpenJDK 12.

We briefly review the results obtained from these tests and refer to the companion technical report [6] for more details.

Time vs. Number of Zones. In this case we evaluate how our implementation scales with an increasing number of zones; see Fig. 7. We can see that the running time grows exponentially, especially the resolution time. Similarly to the previous test case, the time spent building the CSP and applying the reaction rule is negligible even though we can see that the time necessary to build the CSP increases linearly with the grid size. We can also observe that there is no correlation between the rewriting time and the number of zones.

Fig. 7.

Execution times vs. number of zones, 70 cars and 100% connectivity.

Time vs. Connectivity Degree. In this case we evaluate how our implementation scales with an increasing connectivity degree; see Fig. 8. We can see that the running time scales exponentially, no matter the grid size or the number of cars. Once again, we see that although increasing, the time spent building the model and applying the rewriting rule is negligible.

Fig. 8.

Execution times vs. connectivity, grid and 70 cars.

Conclusions and Future Works

In this paper, we have presented a new version of directed bigraphs and bigraphic reactive systems, which subsume previous versions (such as Milner’s bigraphs). For this kind of bigraphs we have provided a sound and complete algorithm for solving the embedding problem, based on a constraint satisfaction problem. The resulting model is compact and the a number of variables and linear constraints are polynomially bounded by the size of the guest and host bigraphs. Differently from existing solutions, this algorithm applies also to non-ground hosts.

The algorithm has been successfully integrated into jLibBig, an extensible library for manipulating bigraphical reactive systems. The empirical evaluation of the implementation of our algorithm in jLibBig looks promising. It cannot be considered a rigorous experimental validation yet, mainly because performance depends on the implementation and the solver and the model is not optimized for any specific solver. Moreover, up to now there are no “official” (or “widely recognized”) benchmarks, nor any other algorithms or available tools that solve the directed bigraph embedding problem, to compare with.

The proposed approach offers great flexibility: it can be easily applied also to other extensions of bigraphs and directed bigraphs. An interesting direction for future work would be to extend the algorithm also to stochastic and probabilistic bigraphs [18]; this would offer useful modelling and verification tools for quantitative aspects, e.g. for systems biology [2, 8]. Approximated and weighted embeddings are supported in jLibBig, but still as experimental feature. In fact, the theoretical foundations of these extensions have not been fully investigated yet, suggesting another line of research.