Tool Graph: Interaction Net Visualization

• Tool Graph is a graphical computational model for creating, visualizing, and transforming interaction nets with explicit port mappings and formal rewriting rules.
• It supports intuitive node and edge editing, rule definition, and automatic constraint enforcement to maintain system consistency.
• It integrates scalable visualization with dynamic layouts and a strategy language that enables precise control and traceability of graph transformations.

A tool graph, as developed in the context of "Graph Creation, Visualisation and Transformation," refers to a graphical environment and computational model focused on the creation, visual manipulation, and rule-based transformation of interaction nets—a class of graph rewriting systems with strong formal properties and applications in modelling computation.

1. Tool Graphs for Interaction Nets: Core Principles

The principal innovation is embodied in the GraphPaper editor, designed to allow users to draw, manage, and transform graphs that conform to the syntax and semantics of interaction nets. An interaction net consists of agent nodes with labeled ports (one principal, several auxiliary), connected by edges at the port level. Graphs are modified not by global operations but by localized application of rules that act on specific pairs of agents connected via their principal ports.

Key features in tool graph creation:

• Node/Edge creation and editing: Users draw circles to create agent-nodes, with lines for port connections; auxiliary and principal ports are distinctly represented.
• Transformation rule definition: The interface supports intuitive drawing of rewriting rules as left-hand side (LHS) and right-hand side (RHS) patterns, with port-to-port mapping (interface mapping) made explicit via colored links.
• Constraint enforcement: The editor automatically ensures interaction net properties are maintained (such as one principal port per agent).

This tool graph framework is both the data structure underlying the user interface and the operational model guiding the computation.

2. Scalable Visualization and Traceability

The tool graph approach is supported by integration with the TULIP visualization platform. Graphs comprised of up to one million elements can be rendered and manipulated interactively, which is essential when repeated applications of graph rewriting rules lead to significant state expansion or contraction.

Visualization advances include:

• Dynamic layouts: Graphs automatically rearrange as rewriting rules are applied, supporting multiple visualization models (cone tree, circular, planar).
• Real-time feedback: Immediate visual updating after each transformation ensures the evolving structure remains readable.
• State traceability: The tool maintains a trace tree, capturing every rewrite operation and resultant intermediate state, enabling navigation and branching analysis of different rewriting paths.

This emphasis on traceability addresses the challenge of understanding complex, non-linear transformation histories in large graphs.

3. Formal Definition of Interaction Nets within Tool Graphs

Underpinning this system is a precise formalism for interaction nets:

• Agents and Ports: An agent of symbol $\alpha \in \Sigma$ with arity $n$ has $n+1$ ports (one principal, $n$ auxiliary).
• Nets as graphs: Nets are undirected graphs where nodes (agents) are interconnected at ports, and a net’s interface is formed by its free ports.
• Rewriting rules: Each rule replaces a pair of agents connected at principal ports ($\alpha \bowtie \beta$) with a net $N$ that preserves the external interface. Rewrites modify only the matched subgraph, ensuring locality.
• Computational properties: The model exhibits strong confluence—any sequence of reduction steps leads to the same normal form if one exists—and naturally encodes parallelism, as independent redexes (rewritable patterns) can be reduced simultaneously.

These formal features make tool graphs suitable not only for visual editing but also as a vehicle for computational reasoning.

4. Rewriting Strategies and the Strategy Language

A distinguishing aspect of the tool graph environment is its support for a language of rewriting strategies, enabling users to control the application order and location of rules—key for both optimization and partial reduction in confluence-respecting systems.

Strategy grammar:

$$S ::= id \mid fail \mid R \mid S;S \mid S \parallel S \mid S^* \mid S\ \text{or}\ S$$

• Rule application with location/depth control: $R_i(\text{subgraph}, \text{depth})$ specifies the region and neighborhood for rule application.
• Combinators: Sequential ($;$), parallel ($\parallel$), repetition ($^*$), and choice ($\text{or}$) permit expressive control over rewrite sequencing.
• Auxiliary manipulation: Functions like $\mathrm{Interface}(subgraph)$ and $\mathrm{Successors}(subgraph)$ facilitate regional specificity.

The strategy language is location-based, reflecting the absence of a unique root or canonical traversal direction in general graphs. This precise control mechanism is critical where intermediate state sizes, computation time, or partial solutions matter.

5. Applications across Modelling, Programming, and Research

Tool graphs, as implemented in GraphPaper and the supporting system, are adaptable to a variety of use cases:

• Visual programming languages: They serve as editors for programming models built on interaction nets, bringing intuitive graphical semantics to program construction.
• System specification and modelling: The interface's visual nature allows for early-stage prototyping and clear communication of system behavior.
• Research in graph algorithms and rewriting: The facility to craft, trace, and debug rewrite strategies supports experimental inquiry and the paper of graph transformation properties.
• Education: Interactive visualization and automatic enforcement of rewriting constraints make tool graphs a compelling medium for teaching computation models and the theory behind confluence and locality.

Illustrative use cases include graphical manipulation of proof nets, database schema evolution via graph restructuring, and the simulation of distributed protocols.

6. Summary Table: Aspects and Benefits

Aspect	Tool/Feature	Benefits
Graph Editing	Gesture-based, shape recognition	Rapid and natural prototyping
Rule Definition	Visual LHS/RHS, explicit port interface links	Reduces errors, enables intuitive rule designs
Visualization Algorithms	Scalable, dynamic via TULIP	Handles large graphs, preserves structure
Strategy Language	Sequential, parallel, location-aware control	Precise and expressive rewriting management
Tracing/Debugging	Rewrite trace tree navigation	Enables branching and rollback
Application Domains	Programming, modelling, education, research	Broad, cross-disciplinary adaptability

7. Conclusion

The tool graph paradigm—epitomized by GraphPaper and its integration with TULIP—establishes a unified, interactive environment for the complete lifecycle of graph-based reasoning. It combines intuitive construction, rigorous transformation controls, and high-performance visualization, with deep roots in the formalism of interaction nets. This approach supports not only the specification and execution of graph computations but also the development and communication of graph-based systems and research artifacts.