Graph rewriting with polarized cloning

We tackle the problem of graph transformation with a particular focus on node cloning. We propose a new approach to graph rewriting where nodes can be cloned zero, one or more times. A node can be cloned together with all its incident edges, with only its outgoing edges, with only its incoming edges or with none of its incident edges. We thus subsume previous works such as the sesqui-pushout, the heterogeneous pushout and the adaptive star grammars approaches. A rewrite rule is defined as a span where the right-hand and left-hand sides are graphs while the interface is a polarized graph. A polarized graph is a graph endowed with some annotations on nodes. The way a node is cloned is indicated by its polarization annotation. We use these annotations for designing graph transformation with polarized cloning. We show how a clone of a node can be built according to the different possible polarizations and define a rewrite step as a final pullback complement followed by a pushout. This is called the polarized sesqui-pushout approach. We also provide an algorithmic presentation of the proposed graph transformation with polarized cloning.

💡 Research Summary

The paper addresses a long‑standing limitation in graph transformation systems: the coarse‑grained handling of node cloning. Traditional approaches such as the sesqui‑pushout (SqPO), heterogeneous pushout, and adaptive star grammars either allow a node to be cloned completely or not at all, or they treat cloning as an auxiliary mechanism that cannot be finely controlled. To overcome this, the authors introduce polarized graphs, which are ordinary directed graphs equipped with a polarization annotation on each node. The annotation can take one of four values, each describing a distinct cloning policy:

1. Full cloning (⊤) – the node and all its incident edges (both incoming and outgoing) are duplicated.
2. Outgoing‑only cloning (→) – the node is duplicated together with all outgoing edges, while incoming edges remain attached to the original node.
3. Incoming‑only cloning (←) – the node is duplicated together with all incoming edges, leaving outgoing edges untouched.
4. No cloning (⊥) – the node persists but none of its incident edges are copied.

These four polarizations give the system the expressive power to model a wide range of practical scenarios, such as replicating a computation unit while preserving only its output connections, or copying a router’s inbound links without affecting its outbound traffic.

A graph rewriting rule is defined as a span (L \leftarrow I \rightarrow R) where the left‑hand side (L) and right‑hand side (R) are ordinary graphs, while the interface (I) is a polarized graph. The interface therefore carries the cloning policy for each node that participates in the transformation. The rewrite step proceeds in two categorical phases:

1. Final Pullback Complement (FPBC) – Starting from the morphism (L \leftarrow I), the FPBC constructs a maximal “inverse” object that incorporates the cloning dictated by the polarizations. Intuitively, it creates the duplicated nodes and the appropriate subsets of incident edges before any new structure from the right‑hand side is added. The FPBC guarantees that the cloning choices are consistent and that no unintended sharing occurs.

2. Pushout – The second phase takes the FPBC result and the morphism (R \leftarrow I) and forms a pushout. This merges the newly cloned subgraph with the right‑hand side, yielding the final transformed graph (G). Because the pushout is performed after the FPBC has already materialised the cloned nodes, the cloning policy is faithfully respected.

The composition of these two steps is called the polarized sesqui‑pushout (PSqPO) approach. The authors prove that PSqPO subsumes the classic SqPO, heterogeneous pushout, and adaptive star grammars: each of those formalisms corresponds to a particular choice of polarization (e.g., all nodes labelled ⊤ or ⊥). Moreover, PSqPO enjoys the usual categorical properties of graph rewriting systems: it is compositional (two consecutive PSqPO steps can be merged into a single PSqPO rule) and isomorphism‑preserving (graph isomorphisms before rewriting remain isomorphisms after rewriting).

From an algorithmic standpoint, the paper presents a concrete procedure:

• Matching – Find a graph homomorphism from the left‑hand side (L) into the host graph (H). The matching determines which nodes are subject to cloning and transfers their polarization labels to the interface.
• FPBC Construction – For each matched node, generate the required number of clones according to its polarization. The algorithm creates the appropriate incident edges (incoming, outgoing, or both) and assigns fresh identifiers to avoid collisions.
• Pushout Execution – Merge the cloned subgraph with the right‑hand side (R) by identifying the interface nodes, producing the final graph.

The complexity of the algorithm is dominated by the matching phase (typically NP‑complete for general graphs) while the cloning step scales linearly with the number of clones and incident edges. The authors also discuss practical implementation concerns, such as reusing node identifiers to minimise memory overhead and eliminating duplicate edges that may arise when multiple clones share the same target.

To illustrate the expressive power of PSqPO, three case studies are provided:

• Class diagram refactoring – A class node is cloned together with all its outgoing inheritance edges, modelling the creation of a subclass while preserving its super‑class relationships.
• Data‑flow graph optimisation – An operation node is duplicated with only its outgoing data edges, enabling parallel execution of the same computation without duplicating its inputs.
• Network topology reconfiguration – A router node is cloned with only its incoming links, representing the addition of a backup router that receives the same traffic but forwards it differently.

In each scenario, the desired cloning behaviour cannot be expressed cleanly with classic SqPO or adaptive star grammars, but is straightforward with the appropriate polarization annotation.

The paper concludes by highlighting the theoretical contribution (a unified categorical framework for fine‑grained cloning) and practical relevance (more accurate modelling of software, data‑flow, and network transformations). Future work is outlined, including the integration of type systems for polarization labels, optimisation of matching algorithms for large‑scale graphs, and the study of concurrency control when multiple PSqPO rules are applied simultaneously.

Overall, the polarized sesqui‑pushout approach significantly expands the toolbox of graph transformation researchers and practitioners, offering a principled, mathematically sound method to control node cloning at a granular level while preserving the desirable properties of existing rewriting frameworks.