A CSP implementation of the directed bigraph embedding problem

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.



page 15


A CSP implementation of the bigraph embedding problem

A crucial problem for many results and tools about bigraphs and bigraphi...

Directed Graph Embeddings

Definitions of graph embeddings and graph minors for directed graphs are...

Four proofs of the directed Brooks' Theorem

We give four new proofs of the directed version of Brook's Theorem and a...

Gender Bias in Meta-Embeddings

Combining multiple source embeddings to create meta-embeddings is consid...

An SPQR-Tree-Like Embedding Representation for Upward Planarity

The SPQR-tree is a data structure that compactly represents all planar e...

NP-Completeness and Inapproximability of the Virtual Network Embedding Problem and Its Variants

Many resource allocation problems in the cloud can be described as a bas...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1. Introduction

Bigraphical Reactive Systems (BRSs) are a family of graph-based formalisms introduced as a meta-model for distributed, mobile systems (jensen2003bigraphs; milner2009space; miculan2013presheaves). 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 (bundgaard2008formalizing; mansutti2014multi; sahli2019self; burco2019towards). 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 (bacci2009dbtk) and jLibBig (miculan2014csp; jlibbig)), simulation tools (mansutti2015distributed; mansutti2014towards; gassara2019executing), graphical editors (faithfull2013big), model checkers (perrone2012model), modular composition (perrone2011bigraphical), stochastic extensions (krivine2008stochastic), etc.

Along this line, (grohmann2007directed; gm:concur07) introduced directed bigraphs, a strict generalization of Milner’s bigraphs where the link graph is directed (see Figure 1). This variant is very suited for reasoning about dependencies and request flows between components, such as those found in producer-consumer scenarios. In fact, they have been used to design formal models of security protocols (grohmann2008security), molecular biology (bacci2009framework), access control governance (grohmann2008access), container-based systems (burco2019towards), among others.

Figure 1. An example of directed bigraph and its place and link graphs (grohmann2008access).

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 (bacci2014finding). Several algorithms have been proposed in literature for bigraphs with undirected links (see e.g. (glenstrup2007implementation; sevegnani2010sat; damgaard2013inductive; miculan2014csp)), but there are no embedding algorithms 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 Section 2 we first introduce directed bigraphs and bigraphic reactive systems, generalizing (grohmann2007directed; burco2019towards). Then, the notion of directed bigraph embedding is defined in Section 3. In Section 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 (miculan2014csp) on the embedding problem for undirected bigraph. We have implemented this algorithm as an extension of jLibBig (jlibbig), a general Java library for BRSs; this implementation and some experimental results are reported in Section 5. Finally, some conclusions and directions for future work are drawn in Section 6.

2. Reactive systems on Directed Bigraphs

In this section we introduce directed link graphs and bigraphs, and directed bigraphical reactive systems, extending the definitions from (grohmann2007directed; gm:concur07).

2.1. Directed bigraphs

Definition 2.1 (Polarized interface).

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

Definition 2.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 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 (grohmann2007directed) is that we allow also for inward ports in controls, whereas in (grohmann2007directed), like in (milner2009space), controls have only outward ports. This turns out also in the definition of points and handles.

Definition 2.3 (Directed Link Graph).

A directed link graph is a quadruple where and are defined as before, while the link map is defined as where

with the following additional constraints:


The elements of are called the points of ; the elements of are called the handles of .

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 (milner2009space).

Definition 2.4 (Directed Bigraph).

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

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

  • and are the inner and outer interfaces;

  • and are the sets of nodes and edges;

  • 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 is denoted also as .

Directed bigraphs can be composed on matching interfaces.

Definition 2.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 is .

If and are two bigraphs, their composite is and the identity bigraph at is .

Definition 2.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 . It is worthwhile noticing that Milner’s pure bigraphs (milner2009space) correspond precisely to directed bigraphs between ascending (i.e., positive) interfaces only and over signatures with only positive ports.

2.2. 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 is expressed by an instantiation map in the rule.

Definition 2.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 -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 .

The dynamics of bigraphs is expressed in terms of rewriting rules.

Definition 2.8 (Parametric reaction rule).

A parametric reaction rule for bigraphs is a triple of the form where 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 (milner2009space; gm:concur07). Let be the set of agents (i.e., bigraphs with no inner names nor sites) over a signature .

Definition 2.9 (DBRS).

A directed bigraphical reactive system (DBRS) is defined by a signature and a set of rewriting rules. A DBRS induces a rewriting relation via the derivation rule:

where the wiring maps and are give 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 ( 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 such that . We can have two cases:

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

  2. for each , there are one or more pairs such that . This means that for the given source agent decomposition, there can be several ways to define . Each of these possible definitions yields a different application of the same rule (and the same decomposition).

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.

3. 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 within a given bigraph . More formally, this translates to finding and such that . and are called context and parameter.

If we abstract from the decomposition of the agent 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 (hojsgaard2012bigraphical), 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 3.1 (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:


and are injective;




is a partial map as follows:


is a partial map s.t.:











where and is .

The first three conditions are on the single sub-maps of the embedding. Conditions 3.1 and 3.1 ensures that no components (except for outer names) are identified; condition 3.1 imposes that points connected by the image of an edge are all covered. Finally, conditions 3.1, 3.1 and 3.1 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 3.2 (Place graph embedding (hojsgaard2012bigraphical, Def 7.5.4)).

Let and be two place graphs. A place graph embedding is a map (assigning nodes, sites and regions respectively) subject to the following conditions:


is injective;


is fully injective;


in an arbitrary map;


and ;









where , , and .

These conditions follow the structure of Definition 3.1, the main difference is 3.2 which states that the image of a root cannot be the descendant of the image of another. Conditions 3.2, 3.2 and 3.2 are on the three sub-maps composing the embedding; 3.2 and 3.2 ensure that no components are identified; 3.2 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 3.3 (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:





4. 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 encodings contains 37 constraint families (reflecting the complexity of the problem definition, see Section 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.

Network variables

Guest linking

Host points

Host handles

Guest points

Guest handles
Figure 2. Schema of the multi-flux network encoding.
Figure 3. Constraints of DLGE[].

4.1. Directed Link Graphs

Let us fix the guest and host bigraphs and . We characterize the embeddings of into as the solutions of a suitable multi-flux problem which we denote as DLGE[]. 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 Figure 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 edges and optionally taking a “detour” along the linking structure of the guest (provided that some conditions regarding structure preservation are met). The formal definition of the flux problem is in Figure 3.

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 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 ; to be precise, some of these variables will never assume a value different from 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 into and the seconds 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), (2223) 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 -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.


Let be a solution of DLGE[]. The corresponding link graph embedding is defined as:

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

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