Open Graphs and Computational Reasoning

We present a form of algebraic reasoning for computational objects which are expressed as graphs. Edges describe the flow of data between primitive operations which are represented by vertices. These graphs have an interface made of half-edges (edges which are drawn with an unconnected end) and enjoy rich compositional principles by connecting graphs along these half-edges. In particular, this allows equations and rewrite rules to be specified between graphs. Particular computational models can then be encoded as an axiomatic set of such rules. Further rules can be derived graphically and rewriting can be used to simulate the dynamics of a computational system, e.g. evaluating a program on an input. Examples of models which can be formalised in this way include traditional electronic circuits as well as recent categorical accounts of quantum information.

💡 Research Summary

The paper introduces a unified algebraic framework for reasoning about computational objects that are represented as directed graphs. In this setting, vertices denote primitive operations (such as logical gates, quantum unitaries, or functional primitives) and edges encode the flow of data between them. A distinctive feature is the use of half‑edges—edges with one free end—that serve as explicit input and output ports, thereby giving each graph an interface that can be connected to other graphs in a compositional manner. This “open graph” notion enables the definition of equations between graphs (asserting that two graphs have the same operational behavior) and rewrite rules that transform one graph into another while preserving semantics.

The authors first formalize open graphs using category‑theoretic language, defining objects (graphs with half‑edges) and morphisms (structure‑preserving maps that may permute half‑edges). Graph equivalence is captured by isomorphisms that respect both the internal wiring and the external ports. On top of this foundation they introduce a rule language: a rule consists of a left‑hand side pattern (a subgraph possibly containing half‑edges) and a right‑hand side replacement. Pattern matching is performed modulo graph isomorphism, and the application of a rule rewires the surrounding context by reconnecting the half‑edges of the replaced subgraph to those of the new subgraph.

Two families of basic rules are distinguished. “Operator‑operator” rules rewrite the connection between two operation vertices, enabling transformations such as gate fusion, associativity rearrangements, or the application of categorical identities (e.g., the spider fusion rule in ZX‑calculus). “Operator‑data” rules handle the interaction between an operation and a concrete datum (a constant, an input token, or a prepared quantum state), supporting optimizations like constant propagation or state initialization. By iterating these rules, complex derivations can be built, mirroring traditional term‑rewriting systems but with the richer topology of graphs.

To give the rewriting process a precise meaning, the paper defines a dynamic semantics. Each graph carries a set of data tokens that travel along edges according to the operational semantics of the vertices. When a rewrite rule is applied, the graph structure changes, and the token flow is recomputed from the new configuration. This semantics is compositional: the behavior of a composite graph is determined solely by the behaviors of its components and the way their ports are connected. Consequently, no external control structures (stacks, instruction pointers, etc.) are required; the graph itself encodes the entire computation.

The framework is illustrated with two substantial case studies. In the electronic‑circuit domain, logical gates (AND, OR, NOT) and storage elements (flip‑flops) become vertices, wires become edges, and the circuit’s external pins are half‑edges. Rewrite rules encode classic circuit optimizations such as NAND‑only conversion, gate‑level minimization, and timing‑aware restructuring. The authors show how a complete circuit can be evaluated by repeatedly applying rules that propagate signals and simplify sub‑circuits, effectively simulating the circuit’s dynamic behavior.

In the quantum‑information domain, the authors map the ZX‑calculus—a graphical language for quantum processes—onto open graphs. Vertices represent spiders (Z‑ or X‑spiders), Hadamard gates, and measurement nodes; edges represent quantum wires, and half‑edges correspond to prepared input states or measurement outcomes. The well‑known ZX rewrite rules (spider fusion, colour change, bialgebra, etc.) become instances of the general graph rewrite formalism. This mapping allows one to prove circuit equivalences, perform automated simplifications, and even reason about error‑correcting codes entirely within the open‑graph framework.

Beyond these examples, the paper argues that the same machinery can model functional programming (functions as vertices, function application as wiring), data‑flow languages, and even neural‑network architectures, because all of them share the fundamental pattern of operations connected by data streams. The open‑graph approach thus offers a visually intuitive yet mathematically rigorous platform for specifying, transforming, and executing a wide variety of computational models.

In summary, the authors present a powerful, compositional, and graph‑centric calculus for computational reasoning. By treating half‑edges as first‑class interfaces, they achieve modularity and reusability; by defining equations and rewrite rules at the graph level, they obtain a uniform method for specifying semantics, deriving new identities, and simulating execution. The case studies demonstrate that both classical hardware and cutting‑edge quantum formalisms fit naturally into this paradigm, suggesting that open graphs could become a foundational tool for future research in programming language theory, hardware design, and quantum computing.