Strategic Graph Grammars (SGs) Overview

• Strategic Graph Grammars (SGs) are a declarative formalism that integrates port-graph rewriting with an expressive strategy language for controlled graph transformations.
• They enable precise control over rule application and position selection, supporting applications in arithmetic computation, combinatorial search, and interactive games.
• Implemented in the PORGY environment, SGs provide structured strategies such as depth-first, round-robin, and prioritized rule applications along with advanced visualization.

Strategic Graph Grammars (SGs) are a declarative programming formalism integrating port-graph rewriting systems with an expressive, high-level strategy language for controlling rule application. Defined within the framework of the PORGY environment, SGs enable explicit control over both the selection of rewriting rules and their location of application within a graph, supporting the development of complex graph-based algorithms and visual programs across domains such as arithmetic computation, combinatorial search, and interactive games (Fernández et al., 2010).

1. Port-Graph Rewriting Framework

SGs are built upon the port-graph formalism. A port graph is defined by a tuple $(V, E, lab, src, tgt)$, where $V$ is a set of nodes and $E$ is a set of edges. Nodes are labelled by elements of an alphabet $\mathcal{N}$, and each node has attached ports specified by a $p$-signature $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$ assigning a finite, pairwise disjoint set of ports to each node-name. Edges attach to ports $(p, v)$, ensuring that all connections respect node types and port assignments.

Rewriting operates via rules $L \Longrightarrow R$, themselves port graphs, with a distinguished "arrow node" encoding the interface between $L$ and $R$. To apply a rule to a host graph $V$0, one finds an injective match $V$1, replaces $V$2 by $V$3, and reconnects any dangling edges according to the arrow node interface, formally yielding $V$4.

2. Strategy Language: Syntax and Operational Semantics

The inherent non-determinism of graph rewriting—stemming from numerous possible rule applications at multiple positions—is managed by a strategy language in PORGY. Its core abstraction is the located graph $V$5, where $V$6 is a position subgraph. All rule applications during a rewriting step must overlap $V$7.

The language consists of three primary syntactic classes:

• Position transformations ($V$8): Reshape or manipulate the current position $V$9. Constructs include $E$0 (returning $E$1), $E$2 (immediate successors), $E$3 (nondeterministically chosen successor), $E$4, and operations such as union, intersection, complement, set difference, and property-based filtering.
• Applications ($E$5): Express single or parallel rewrite steps, including $E$6 (no-op), $E$7, localized rule applications $E$8, parallel ($E$9), alternative ($\mathcal{N}$0), and bounded parallel iteration ($\mathcal{N}$1).
• Strategies ($\mathcal{N}$2): Combinators over $\mathcal{N}$3 and $\mathcal{N}$4, including sequence ($\mathcal{N}$5), choice ($\mathcal{N}$6), randomized pick ($\mathcal{N}$7), bounded and unbounded iteration ($\mathcal{N}$8), test ($\mathcal{N}$9), emptiness check ($p$0), and atomic visualization blocks ($p$1).

Operational semantics are formalized as a small-step rewrite system on configurations $p$2. Representative inference rules include sequential and alternative compositions, with execution driven by a top-down meta-strategy, ultimately yielding either a diverging computation or terminal states $p$3 or $p$4.

3. Structure and Authoring of SGs

An SG comprises a triple $p$5:

• $p$6: Agent symbols (node types)
• $p$7: Set of port-graph rewrite rules $p$8
• $p$9: Initial port graph
• $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$0: Initial position subgraph of $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$1
• $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$2: Main strategy controlling execution

Program execution starts from configuration $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$3. SGs thus encapsulate structural, dynamic, and control aspects needed to express complex computations declaratively.

4. Illustrative Patterns and Examples

Typical control idioms include:

• Depth-first rule application: Achieved by iterative strategies such as $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$4 where $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$5, exhausting all deeper matches before backtracking.
• Fair round-robin application: Employs $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$6, iteratively picking any available rule.
• Prioritized rule application: Encoded via nested choices, e.g., $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$7.

The framework supports a wide spectrum of use cases:

• Labyrinth path finding: A strategy iteratively advances "Pather" agents via branching rewrite rules, terminating when one reaches the "End" node. Drawing rules reconstruct the shortest path. Distinguishing features include concurrent agent advance, position re-rooting, and alternation of exploration and retracing phases.
• Integer arithmetic, fractal generation, and interactive games: Algorithms ranging from efficient arithmetic evaluation (via interaction nets) to the construction of Von Koch fractals and Pac-Man gameplay are expressed via a combination of concise rule sets and high-level strategies.

5. Expressiveness and Theoretical Properties

SGs are highly expressive, incorporating:

• Termination: Unbounded iteration and parallelism may produce non-termination, depending on $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$8 and $\nabla:\mathcal{N}\rightarrow 2^{\mathcal{P}}$9. Programmers can enforce bounds using $(p, v)$0 parameters, but no built-in termination checking exists.
• Confluence: General port-graph rewriting is not confluent; strategies can enforce determinism by constraining rule/position selection. Interaction nets offer stronger confluence but SGs extend beyond pure nets.
• Comparative expressiveness: Relative to term rewriting environments (ELAN, Tom, Stratego), SGs natively incorporate graph-based positions and parallel application. In contrast with systems such as GP, AGG, Fujaba, PROGRES, GROOVE, and GrGen, SGs' distinct contribution is first-class position transformations integrated with strategy combinators. The strategy language is Turing-complete, strictly subsuming GP by virtue of explicit positions.

6. Practical Implementation, Limitations, and Prospects

The PORGY tool situates the strategy language within an interactive environment leveraging the TULIP engine for graph visualization. Users draw graphs and rules, script strategies, execute derivations either stepwise or in batch, and inspect both the trajectory of positions and the evolution of the graph.

Noted limitations include:

• Absence of built-in termination or confluence analysis (identified as targets for future static analyses).
• A non-minimal strategy core, with potential for reduction to canonical calculi.
• Restriction to port-graphs; planned extensions to hypergraphs and term graphs.

Prominent directions for extension encompass higher-order strategies (strategies as data), dedicated debugging and profiling, typed strategies (with a graph-type system), and richer probabilistic/quantitative variants to support stochastic simulations.

SGs, through the synergy of port-graph rewriting and a granular, compositional strategy language, deliver an approach wherein both the dynamics (how to rewrite) and the locale (where to rewrite) of graph transformations are precisely programmable, offering a foundation for implementing a rich class of graph-oriented algorithms and interactive computational artifacts (Fernández et al., 2010).