Constant Delay Traversal of Grammar-Compressed Graphs with Bounded Rank

TL;DR

This paper introduces a pointer-based data structure enabling constant-time traversal of edges in grammar-compressed hypergraphs with bounded rank, optimizing navigation efficiency in complex graph representations.

Contribution

It presents a novel data structure for hypergraph traversal that operates in constant time, specifically tailored for graphs generated by hyperedge-replacement grammars with bounded rank.

Findings

Supports constant-time traversal of hypergraph edges

Preprocessing requires space proportional to grammar size and parameters

Applicable to hypergraphs with fixed maximum rank and specific incident edge constraints

Abstract

We present a pointer-based data structure for constant time traversal of the edges of an edge-labeled (alphabet $\Sigma$) directed hypergraph (a graph where edges can be incident to more than two vertices, and the incident vertices are ordered) given as hyperedge-replacement grammar $G$. It is assumed that the grammar has a fixed rank $\kappa$ (maximal number of vertices connected to a nonterminal hyperedge) and that each vertex of the represented graph is incident to at most one $\sigma$-edge per direction ($\sigma \in \Sigma$). Precomputing the data structure needs $O(|G||\Sigma|\kappa r h)$ space and $O(|G||\Sigma|\kappa rh^2)$ time, where $h$ is the height of the derivation tree of $G$ and $r$ is the maximal rank of a terminal edge occurring in the grammar.

Equations

$$g[e/h]=g[-e]\cup h[\rho ].$$

$$S$$

$$A$$

$$B$$

$$S$$

$$\Rightarrow aAbB$$

$$\Rightarrow aaAbbB$$

$$\Rightarrow aaabbbB$$

$$\Rightarrow aaabbbcB$$

$$\Rightarrow aaabbbcc$$

$${\le }_{\mathsf{NT}}=$$

$$\cup \{(S,A)\in \{S\}\times N\mid \exists e\in E_S:{\mathsf{lab}}_S(e)=A\}$$

$$\rho (x)=\{\begin{array}{ll}{\mathsf{att}}_g(e)[i]& \text{ if x is the i-th external node of h}\\ n+x& \text{ otherwise}\end{array}.$$

$$\mathsf{first}(u)=\mathsf{first}(v)+\sum _{j<i}\mathsf{i}\text{-}\mathsf{nodes}(\mathsf{lab}(e_j))+|V_{g_{s,v}}|-|{\mathsf{ext}}_{g_v}|.$$

$$\mathsf{vertex}(u,x)=\mathsf{first}(u)+x$$

$$\mathsf{vertex}(u_4,1)$$

$$=\mathsf{first}(u_2)+|V_{\mathsf{rhs}(A)}|-|{\mathsf{ext}}_{\mathsf{rhs}(A)}|+\mathsf{i}\text{-}\mathsf{nodes}(B)+1$$

$$=\mathsf{first}(u_1)+|V_S|-|{\mathsf{ext}}_S|+|V_{\mathsf{rhs}(A)}|-|{\mathsf{ext}}_{\mathsf{rhs}(A)}|+\mathsf{i}\text{-}\mathsf{nodes}(B)+1$$

$$=0+2-0+4-2+1+1=6.$$

$$\mathsf{findVertex}(t(i,j))=\{\begin{array}{ll}\mathsf{nxt}(t(i,j))& \text{if nxt(t(i,j)) is upwards}\\ \mathsf{nxt}(\mathsf{nxt}(t(i,j)))& \text{if nxt(t(i,j)) is downwards}\end{array}.$$

$$t(i,j)=$$

$$t^{\mathsf{nt}}(i)=$$

$$t^{\mathsf{first}}(i)=$$

$$t^{\mathsf{off}}=$$

Full text

1 Introduction

Straight-line grammars are context-free grammars that produce one object only (see, e.g. [2, 15, 20]). The term “straight-line” refers to the restriction that such grammars have no recursion (i.e., there is no derivation from a nonterminal to itself) and have no non-determinism (i.e., for each nonterminal there is exactly one rule). The most well-known type of straight-line (SL) grammars are string grammars which are also known as straight-line programs (SLPs). SLPs are a convenient formalism for data compression due to several reasons: they generalize a number of classical compression schemes, such as Lempel-Ziv and they are mathematically clean and simple, which has fostered the development of a wealth of algorithms for compressed data. Note that an SLP can be exponentially smaller than the object it represents. For many problems algorithms exist that run over the compressed (grammar-based) representation within a similar time bound (say, polynomial time) as over the original uncompressed object; examples include pattern matching, testing equivalence, and evaluating simple queries (e.g., queries expressed by finite state automata), and more as given in a survey [15]. SLPs have been generalized to trees [6, 17] (see the survey [16]) by the use of so called “straight-line linear context-free tree grammars”, for short SL tree grammars. In an SL tree grammar, nonterminals may have argument trees, i.e., nonterminals may appear at inner nodes of the right-hand side of a rule. A rule with right-hand side $t$ is applied to such an inner node, by replacing the node by $t$ and by afterwards inserting copies of the subtrees of the node at leaves of $t$ that are labeled by special place-holders called “parameters”. In SL tree grammars, each parameter may occur at most once, so that at most one copy of a subtree is inserted. This linearity restriction guarantees that at most exponential compression ratios are achieved (non-linear SL context-free tree grammars can have double-exponential ratios; such grammars have not been studied much [19]). Note that an SL tree grammar that produces a monadic tree is an SLP.

Recently, SLPs have been generalized to (hyper) graphs [22] by using straight-line context-free hyperedge replacement grammars [8, 9], for short, SL HR grammars. In such a grammar, hyperedges labeled by nonterminals are replaced by hypergraphs. If such a hyperedge is incident with the vertices $v_{1},\dots,v_{k}$ (in that order, i.e., hyperedges are ordered), then the replacement consists of

removing the nonterminal hyperedge, 2. 2.

inserting a disjoint copy of the right-hand side $g$ of the rule, and 3. 3.

identifying the $j$-th “external vertex” of $g$ with $v_{j}$.

Thus, external vertices are used in a similar way as the parameters in a tree grammar (in a linear tree grammar, to be precise). In fact, every SL tree grammar can be seen as a particular tree generating SL HR grammar [22, Section 4.4]. SL HR grammars are more complex than SL tree grammars: e.g., it is not known yet whether isomorphism of the graphs represented by two SL HR grammars is decidable in polynomial time (for SLPs this is well-known and can easily be used to solve also the equivalence problem of SL tree grammars in polynomial time).

Let us now consider the traversal of objects represented by SL grammars. E.g., in an SLP, we would like to traverse the letters of the represented string from left-to-right. If implemented naively, a single traversal step may require $O(h)$ time, where $h$ is the height of the derivation tree of the grammar: the current letter is produced by the right-most leaf of a derivation subtree (say, a subtree of the root node), and the next letter to the right is produced by the left-most leaf of the next derivation subtree. We would like to have a data structure which allows to carry out any traversal step in constant time, and which can be computed from the grammar in linear (or polynomial) time. This problem was solved for SLPs by Gasieniec et al. [11] and was later extended to SL tree grammars [18]. The idea of these solutions is to generate terminal objects only in the leaves of the derivation tree and to represent the leaves of the derivation tree by certain “left-most derivations”. Such derivations allow to move from one leaf of the derivation tree to the next leaf (or the previous one) in constant time (see also Section 4.1 below). An independent method provides navigation and certain other tree queries in time $O(\log|t|)$ for an unranked tree $t$, and is able to represent tree nodes in $O(\log|t|)$ space [5].

One drawback of the left-most-derivation approach is that it is hard to adapt it to more general grammar formalisms. For instance, we were not able to generalize the approach to SL graph grammars. Here, the difficulty arises from the fact that we can not assume that terminal objects are only produced in leaves of the derivation tree. In fact, also for SL tree grammars the left-most-derivation approach can only be applied after bringing the grammar in a particular (“string like”) normal form where each nonterminal uses at most one parameter [19]. It remains open in the paper [18] and completely unclear how to apply the left-most-derivation approach to SL tree grammars with nonterminals using several parameters. This is unfortunate because the normal form causes a blow-up in grammar size that can be bounded by a factor of $r$, where $r$ is the maximal rank of terminal symbols [10, 14, 19].

We present a new data structure for constant delay traversal of hypergraphs represented by SL HR grammars. A single traversal step consists of moving from a vertex $x$ along a direction of a hyperedge $e$ to a vertex $y$. A direction is given by a pair $(i,j)$ of integers and means the following: $x$ must be the $i$-th incident vertex of $e$, and $y$ must be the $j$-th incident vertex of $e$. Our graph grammars must obey the following restriction: each vertex of the represented graph is incident with at most one $\sigma$-labeled edge per direction, for every edge label $\sigma\in\Sigma$. Thus, the graphs have a vertex degree that is bounded by $O(|\Sigma|r)$, where $r$ is the maximal number of nodes incident to any given edge. This is a strong restriction. We discuss whether it is necessary in Section 5. We note that any tree grammar is covered by this restriction and our data structure can therefore be used to navigate arbitrary SL tree grammars (in particular ones not in normal form).

Let us consider our solution in more detail. A rule of an SL graph grammar is of the form $A\to g$ where $A$ is a nonterminal of rank $\kappa$, for some natural number $\kappa$, and $g$ is a hypergraph with $\kappa$ external vertices (this is an ordered set of specially marked vertices, as described earlier). The rule is applied to a hyperedge labeled $A$ by replacing the edge by the graph $g$ and identifying the $i$-th vertex of the edge with the $i$-th external vertex of $g$. This means that the vertices identified with external vertices have already been produced earlier in the derivation; more precisely, they have been produced by rules where these vertices are internal (= not external). The key idea of our constant delay traversal is to maintain mappings from external vertices to the rules that produced the corresponding internal vertices. These mappings allow constant-time “jumps” in the derivation tree, similar to (but more general than) left-most derivations. Intuitively, for every nonterminal, every of its internal vertices $x$, and every edge label $\sigma$, we precompute a “tableau” that contains the shortest derivation of the $\sigma$-edge incident to $x$ (if it exists). In a traversal step, we merge tableaux, which requires to manipulate up to $\kappa$-many pointers, where $\kappa$ is the maximal rank of a nonterminal in $G$, defined as the maximal number of external vertices appearing in any right-hand side of $G$’s rules. Thus, our traversals are constant delay for grammars of fixed maximal rank, and our precomputed data structures occupy space in $O(|G||\Sigma|\kappa hr)$ where $\kappa$ is the maximal rank of the nonterminals in $G$, $h$ is the height of the derivation tree of the grammar $G$, and $r$ is the maximal rank of a symbol in $\Sigma$.

A preliminary version of this paper appeared at DCC 2018 [21]. The present version is extended by allowing for traversal on general hyperedges, commenting on limits of the methods, and providing proofs.

2 Preliminaries

For $k\geq 0$ we denote by $[k]$ the set $\{1,\ldots,k\}$. A ranked alphabet consists of an alphabet (that is, a finite set of symbols) $\Sigma$ together with a mapping $\mathsf{rank}:\Sigma\rightarrow\mathbb{N}$ that assigns a rank to every symbol in $\Sigma$. For the rest of the paper we assume that $\Sigma$ is a fixed set $\{\sigma,\sigma_{1},\ldots\sigma_{m}\}$ for some $m\in\mathbb{N}$. The empty string is denoted by $\varepsilon$, and for two strings $u,v$ the concatenation of $u$ and $v$ is denoted by $u\cdot v$, or $uv$ if that is unambiguous. The length of a string $u$ is denoted by $|u|$. We denote by $u[i]$ the symbol at position $i$ of $u$ (starting with $1$). Let $k=\max\{\mathsf{rank}(\sigma)\mid\sigma\in\Sigma\}$ be the maximal rank of any symbol within $\Sigma$. We define ranked, ordered trees as a tuple $(V,\lambda,\mathsf{root},E)$ where $V$ is a set of nodes, $\lambda:V\to\Sigma$ a node labeling, $\mathsf{root}\in V$ is the root node, and $E\subseteq V\times[k]\times V$ is a set of edges such that $(u,i,v)\in E$ means that $v$ is the $i$-th child of $u$ and we call $u$ the parent of $v$. For a node $u$ we denote by $E(u)=\{(u,i,v)\in E\}$ the set of edges originating in $u$. We require that

every node $v$ has exactly $\mathsf{rank}(\lambda(v))$ children (i.e., $|E(v)|=\mathsf{rank}(\lambda(v))$), 2. 2.

for any node $u$ there is at most one pair $i,v$ such that $(u,i,v)\in E$, and 3. 3.

every node has exactly one parent, except the node $\mathsf{root}$ which has no parent.

For a node $u$ in the tree $(V,\lambda,\mathsf{root},E)$, the subtree rooted in $u$ is the tree $(V^{\prime},\lambda,u,E^{\prime})$ where $V^{\prime}\subseteq V$ contains the nodes reachable from $u$ and $E^{\prime}\subseteq E$ the edges of $E$ involving nodes in $V^{\prime}$.

The nodes of a tree $s$ can be addressed by their Dewey addresses $D(s)$. For a tree $s=(V,\lambda,\mathsf{root},E)$, $D(s)$ is recursively defined as $D(s)=\{\varepsilon\}\cup\bigcup_{(\mathsf{root},i,u)\in E(\mathsf{root})}i.D(s_{u})$ where $s_{u}$ is the subtree of $s$ rooted at $u$. Thus $\varepsilon$ addresses the root node and $u.i$ the $i$-th child of the node $u$. Intuitively the Dewey address of a node $u$ is the sequence of edge indices encountered on the path from the root of the tree to $u$. We generally use a node $u\in V$ and its Dewey address interchangeably. The size of $s$ is $|s|=|E|$.

A hypergraph over $\Sigma$ (or simply, a graph) is a tuple $g=(V,E,\mathsf{att},\mathsf{lab},\mathsf{ext})$ where $V$ is the finite, non-empty set of vertices, $E$ is a finite set of edges, $\mathsf{att}:E\rightarrow V^{+}$ is the attachment mapping, $\mathsf{lab}:E\rightarrow\Sigma$ is the label mapping, and $\mathsf{ext}\in V^{*}$ is a string of external vertices. A vertex $x\in V$ is external if $x\in\mathsf{ext}$ and is internal otherwise. The vertex $\mathsf{ext}[i]$ for $i\in[|\mathsf{ext}|]$ is also referred to as the $i$-th external vertex of $g$. We refer to the components of $g$ by $V_{g},E_{g},\mathsf{att}_{g},\mathsf{lab}_{g}$, and $\mathsf{ext}_{g}$. We define the rank of an edge as $\mathsf{rank}(e)=|\mathsf{att}(e)|$ and require that $\mathsf{rank}(e)=\mathsf{rank}(\mathsf{lab}(e))\geq 1$ for every $e$ in $E$. Thus an edge labeled with $\sigma$ has $\mathsf{rank}(\sigma)$ many attached nodes and we do not allow edges without attached vertices. We add the following restriction: for every $e\in E$, $\mathsf{att}(e)$ contains no vertex twice. The rank of a hypergraph $g$ is defined as $\mathsf{rank}(g)=|\mathsf{ext}_{g}|$. We call a graph unique-labeled, if for any vertex $x$, $\sigma\in\Sigma$, and $i$ there is at most one edge $e$ with $\mathsf{att}(e)[i]=x$ and $\mathsf{lab}(e)=\sigma$. We denote the set of all hypergraphs over $\Sigma$ by $\mathsf{HGR}(\Sigma)$. Figure 1 shows an example of a hypergraph with 2 external vertices. Formally, the pictured graph has $V=\{v_{1},v_{2},v_{3}\}$, $E=\{e_{1},e_{2},e_{3}\}$, $\mathsf{att}=\{e_{1}\mapsto v_{2}\cdot v_{1},e_{2}\mapsto v_{1}\cdot v_{3},e_{3}\mapsto v_{2}\cdot v_{1}\cdot v_{3}\}$, $\mathsf{lab}=\{e_{1}\mapsto a,e_{2}\mapsto b,e_{3}\mapsto A\}$, and $\mathsf{ext}=v_{2}\cdot v_{3}$. Note that external vertices are filled black and their position within $\mathsf{ext}$ is given by a number under or above the vertex. Hyperedges of rank greater than $2$ are represented by labeled boxes. The boxes have edges to their attached vertices; these edges are labeled by indices indicating the order of the attached vertices. Rank-2 edges are drawn directed, from their first to second attached vertex.

Remark*.*

Both, trees and graphs, are structures with “nodes”. Since we use both types of structures in combination, we use the following convention to avoid confusion: we always refer to nodes of a tree as “node(s)”, and exclusively use “vertex/vertices” for graphs.

Computation model

We assume the use of a word RAM model with registers containing $\beta$-bit words for some number $\beta\in\mathbb{N}$. The space of a data structure is measured by the number of registers it uses. Registers are addressed by numbers, which we refer to as pointers, and can be randomly accessed in constant time. Arithmetic operations (we only need addition) and comparisons of the contents of two registers can be carried out in constant time.

3 Representing graphs using SL HR grammars

This section defines the grammar model used to represent graphs. We use hyperedge replacement grammars, see e.g. [13, 8, 9]. The straight-line restriction, as known from string (see e.g. [15, 2]) and tree grammars (see [16] for a survey) guarantees that a grammar produces at most one object. It was studied for hyperedge replacement grammars in [22]. Note that contrary to strings and trees, the restriction no longer guarantees that the language of a grammar contains only one element. It merely guarantees that every graph in the language of a graph grammar is isomorphic. We discuss the formal details below and also explain how we get from a language of isomorphic graphs to one unique graph (Section 3.1).

Definition 3.1**.**

A hyperedge replacement grammar over $\Sigma$ (for short, HR grammar) is a tuple $G=(N,P,S)$, where $N$ is a ranked alphabet of nonterminals with $N\cap\Sigma=\emptyset$, $P\subseteq N\times\mathsf{HGR}(\Sigma\cup N)$ is the set of rules (or productions) such that $\mathsf{rank}(A)=\mathsf{rank}(g)$ for every $(A,g)\in P$, and $S\in\mathsf{HGR}(\Sigma\cup N)$ is the start graph with $\mathsf{rank}(S)=0$.

We often write $p:A\rightarrow g$ for a rule $p=(A,g)$ and call $A$ the left-hand side $\mathsf{lhs}(p)$ and $g$ the right-hand side $\mathsf{rhs}(p)$ of $p$. We call symbols in $\Sigma$ terminals. Consequently an edge is called terminal if it is labeled by a terminal and nonterminal otherwise. To define a derivation we first need to define how to replace a nonterminal edge $e$ by a graph $h$. This replacement intuitively removes $e$ and replaces it with an isomorphic copy of $h$ such that the external vertices of $h$ are merged, in order, with the vertices attached to $e$. The formal definition is slightly more involved, see also Figure 2 for a specific example of an edge replacement (replacing the red edge $e$ in the graph $g$ with the graph $h$ given below), annotated with all the formal details. We need to introduce some notation. Let $g$ be a hypergraph and $\mathcal{V}$ the set of all possible vertices. Let $\rho:V_{g}\rightarrow\mathcal{V}$ be an injective function, and $\rho^{*}:V_{g}^{*}\rightarrow\mathcal{V}^{*}$ its extension to strings. We call $\rho$ a vertex renaming on $g$. We define $g[\rho]=(\{\rho(v)\mid v\in V_{g}\},E_{g},\mathsf{att}^{\rho},\mathsf{lab}_{g},\rho(\mathsf{ext}_{g}))$, where $\mathsf{att}^{\rho}(e)=\rho^{*}(\mathsf{att}_{g}(e))$ for all $e\in E_{g}$. For a hypergraph $g$ and an edge $e\in E_{g}$ we denote by $g[-e]$ the hypergraph obtained from $g$ by removing the edge $e$. For two hypergraphs $g,h$ we denote by $g\cup h$ the union of the two hypergraphs defined by $(V_{g}\cup V_{h},E_{g}\uplus E_{h},\mathsf{att}_{g}\uplus\mathsf{att}_{h},\mathsf{lab}_{g}\uplus\mathsf{lab}_{h},\mathsf{ext}_{g})$. Note that this union

merges vertices that exist in both $g$ and $h$ and 2. 2.

creates disjoint copies of $E_{h}$, $\mathsf{att}_{h}$, and $\mathsf{lab}_{h}$, and 3. 3.

uses the external vertices of $g$ only.

Now, let $g,h$ be hypergraphs. Let $e\in E_{g}$ such that $\mathsf{rank}(e)=\mathsf{rank}(h)$. Then let $\rho$ be a renaming of $h$ that identifies the external vertices of $h$ with the vertices $e$ is attached to (i.e., $\rho(\mathsf{ext}_{h}[i])=\mathsf{att}_{g}(e)[i]$ for all $i\in[\mathsf{rank}(h)]$) and uses fresh identifiers for all internal nodes of $h$ (i.e., $\rho(\{v\mid v\in V_{h},v$ is internal$\})\cap V_{g}=\emptyset$). The replacement of $e$ by $h$ in $g$ is defined as

[TABLE]

Let $g$ be a graph with a nonterminal edge $e$. A derivation step is defined as $g\Rightarrow h$ if there exist a nonterminal edge $e$ in $g$ and a rule $\mathsf{lab}(e)\to g^{\prime}$ such that $h=g[e/g^{\prime}]$. A derivation $g\Rightarrow^{*}h$ consists of any number of derivation steps and we define the language of $G$ as $L(G)=\{g\in\mathsf{HGR}(\Sigma)\mid S\Rightarrow^{*}g\}$.

Remark*.*

This grammar formalism may be unfamiliar to some readers. We therefore give an example of a string grammar and an equivalent HR grammar to show that HR grammars are a generalization of string grammars. Consider the grammar

[TABLE]

It generates the language $\{a^{n}b^{n}c^{m}\mid n,m\geq 1\}$. Figure 3 shows an equivalent HR grammar, which generates graphs such that their edge labels, read in order, generate the same language. To derive the word $aaabbbcc$ from the above string grammar the following derivation could be used:

[TABLE]

An equivalent derivation of the HR grammar is shown in Figure 4. In this case, the external vertices of the graphs in the right-hand sides mark the beginning and end of the string. This is not necessary in string grammars, because strings implicitly have a given beginning and end. In the figures we identify different internal vertices by using different colors. To show their origin in the grammar, only the saturation changes during derivation, not the hue.

Definition 3.2**.**

An HR grammar $G=(N,P,S)$ is called straight-line (SL HR grammar) if

the binary relation

[TABLE]

defines a single (ordered) directed acyclic graph with vertices $N\cup\{S\}$ rooted at $S$, and 2. 2.

for every $A\in N$ there exists exactly one rule $p\in P$ with $\mathsf{lhs}(p)=A$.

Note that $L(G)\neq\emptyset$ and $L(G)$ is a (potentially infinite) set of isomorphic graphs. As the right-hand side for a nonterminal is unique in SL HR grammars we denote the right-hand side $g$ of $p=(A,g)$ by $\mathsf{rhs}(A)$. By convention whenever we state something over all right-hand sides of a grammar this includes the start graph. The height of an SL HR grammar $0pt(G)$ is the longest distance of any two nonterminals within the DAG induced by $\leq_{\mathsf{NT}}$. We refer by $\kappa=\max_{A\in N}\{\mathsf{rank}(A)\}$ to the maximal nonterminal rank in the SL HR grammar, which we further assume to be fixed for the rest of this paper. In the following we often say grammar instead of SL HR grammar. An SL HR grammar is unique-labeled if the graphs in $L(G)$ are unique-labeled. For the remainder of this paper we will assume every grammar $G$ to be unique-labeled.

3.1 Uniquely identifying vertices

As mentioned in the previous section, $L(G)$ for an SL HR grammar $G$ is a potentially infinite set containing only isomorphic copies of one graph. Since we intend to traverse the vertices of the graph represented by $G$ it is necessary to specify some way to uniquely identify one such vertex. This consequently requires fixing one graph within $L(G)$ to be the value of $G$. In this section we introduce methods to achieve this. Specifically we

define vertices to be numbered with identifiers instead of the arbitrary symbolic sets used up to here, 2. 2.

specify exactly which vertex replacement is used during a derivation step, and 3. 3.

fix a specific derivation of $G$ by defining an order on the nonterminal edges.

Of these steps the latter two are necessary to fix one graph within $L(G)$. The first one simplifies the definition of the vertex replacement and provides a sensible way of representing graphs in an implementation.

We begin with numbering the vertices. We require $V=[n]$ for some $n>0$ for every graph. Furthermore a graph with $k$ external vertices is required to have $\mathsf{ext}=(n-k+1)\cdots n$, i.e., the last $k$ vertices of a graph are its external vertices. Since the vertex numbers thus also imply their position within $\mathsf{ext}$ we now no longer add subscripts in the drawings of graphs indicating this order. These restrictions allow us to specify a vertex renaming during an edge replacement by simple arithmetic. Let $g,h$ be graphs with $n$ and $m$ vertices, respectively. Let $e$ an edge in $g$ with $\mathsf{rank}(e)=\mathsf{rank}(h)$. Then we define $g[e/h]$ as above, but specify $\rho$ as

[TABLE]

That is, the identification of external vertices with the vertices attached to $e$ is the same as before. The internal vertices of $h$ on the other hand are defined to count consecutively starting from $n$, which is the largest vertex number in $g$. Note that, if both $g$ and $h$ have external vertices the graph $g[e/h]$ is not guaranteed to conform to the above restrictions on graphs. In particular it does not necessarily have its external vertices at the end. However, if $g$ is of rank [math] then $g[e/h]$ is also of rank [math] and has the vertices $\{1,\ldots,n+(m-k)\}$.

The changes above already have the effect that $L(G)$ for an SL HR grammar $G$ is now always finite, since the vertex renaming during a derivation step is fixed and there is only a finite number of possible derivations. To now fix one particular graph $\mathsf{val}(G)$ from $L(G)$ as the graph represented by $G$ we fix the order in which nonterminal edges are derived. We do this by defining a derivation tree, which has a node for every nonterminal edge appearing in a full derivation of $G$. The derivation order is then fixed by the depth-first left to right traversal of this tree. We define an order on the nonterminal edges of a graph. Let $\leq_{N}$ be some (arbitrary but fixed) order on the nonterminals of $G$. For a graph $g$ let $E^{\mathsf{nt}}_{g}$ be the set of nonterminal edges in $g$. We define the derivation order $\leq_{\mathsf{dt}}$ on $E^{\mathsf{nt}}_{g}$ in the following way: let $e_{1},e_{2}$ be two edges from $E^{\mathsf{nt}}_{g}$. Then $e_{1}\leq_{\mathsf{dt}}e_{2}$ if

$\mathsf{att}_{g}(e_{i})<_{\text{lex}}\mathsf{att}_{g}(e_{j})$ (here $<_{\text{lex}}$ is the lexicographical order), or

• 2.

$\mathsf{att}_{g}(e_{i})=\mathsf{att}_{g}(e_{j})$ and $\mathsf{lab}_{g}(e_{i})\leq_{N}\mathsf{lab}_{g}(e_{j})$.

Note that $e_{1}=_{\mathsf{dt}}e_{2}$ is possible if $\mathsf{att}(e_{1})=\mathsf{att}(e_{2})$ and $\mathsf{lab}(e_{1})=\mathsf{lab}(e_{2})$. In these cases it is irrelevant for the final result in which order the edges are derived, so they can be ordered arbitrarily.

We now define $\mathsf{val}(A)$ for every nonterminal $A$ and define $\mathsf{val}(G)$ as $\mathsf{val}(S)$. Simultaneously we define the derivation-tree $\mathsf{dt}(A)$ of $A$ and the derivation-tree of $G$ as $\mathsf{dt}(S)$. Note that $\mathsf{dt}(A)$ is a ranked ordered tree with nodes labeled by rules of $G$; the number of children of a node is equal to the number of nonterminal edges in the right-hand side of the rule in the label. Let $g=\mathsf{rhs}(A)$. If $E^{\mathsf{nt}}_{g}=\emptyset$ then $\mathsf{val}(A)=g$ and $\mathsf{dt}(A)=$ a single node labeled $A\to g$. Otherwise let $E^{\mathsf{nt}}_{g}=\{e_{1},\ldots,e_{n}\}$ such that $e_{1}\leq_{\mathsf{dt}}e_{2}\leq_{\mathsf{dt}}\cdots\leq_{\mathsf{dt}}e_{n}$ and for every $i\in[n]$ let $e_{i}$ be labeled by $A_{i}$ and let $s_{i}=\mathsf{dt}(A_{i})$ be trees with disjoint sets of nodes $V_{i}$. Then we define

$\mathsf{val}(A)=g[e_{1}/\mathsf{val}(A_{1})]\dots[e_{n}/\mathsf{val}(A_{n})]$, and

• 2.

$\mathsf{dt}(A)$ as a tree with nodes $\{v\}\cup\bigcup_{i\in\mathsf{rank}(A)}V_{i}$, where $v$ is a new node labeled $A\to g$ and the $i$-th child of $v$ is the root-node of $s_{i}$.

Thus $\mathsf{val}(A)$ is obtained from $\mathsf{rhs}(A)$ by replacing all its nonterminal edges in the order specified by $\leq_{\mathsf{dt}}$.

Figures 5 and 6 show a full example of these notions. This derivation tree and graph will serve as a running example for the methods introduced below. On the left of Figure 5 is an SL HR grammar. Its derivation tree $\mathsf{dt}(G)$ as defined above is given to the right of the grammar, each node of the tree contains its Dewey-address. For an example of the order $\leq_{\mathsf{dt}}$ consider the graph $\mathsf{rhs}(A)$: it has two nonterminal edges $e_{1}$ and $e_{2}$, with $\mathsf{att}(e_{1})=1\cdot 4$, $\mathsf{att}(e_{2})=3\cdot 2\cdot 1$, $\mathsf{lab}(e_{1})=B$, and $\mathsf{lab}(e_{2})=C$. Since $\mathsf{att}(e_{1})<_{\text{lex}}\mathsf{att}(e_{2})$ the derivation order is $e_{1}\leq_{\mathsf{dt}}e_{2}$ and consequently the first child of node $u_{2}$ in the derivation tree is $B\to\mathsf{rhs}(B)$ followed by $C\to\mathsf{rhs}(C)$. Figure 6 shows the graph $\mathsf{val}(G)$. All the nodes in the graph are colored in the same colors as the internal nodes in the derivation tree given in Figure 5 to show which specific derivation they originate from. We invite the reader to reconstruct the full step by step derivation of $\mathsf{val}(G)$ from the given grammar and derivation tree.

Let $A\in N$ and let $u$ be a node in $\mathsf{dt}(A)$. By convention we will use $A_{u}\to g_{u}$ to refer to the label of $u$. For an example consider again the derivation tree in Figure 5. For the node $u_{4}=1.2$ the graph $g_{u_{4}}$ is $\mathsf{rhs}(C)$ and the nonterminal $A_{u_{4}}=C$.

With these conventions regarding vertex numbers and derivation order, we make the following observation: for a graph $g[e/h]$ we can identify whether a vertex originates from $g$ or $h$ from its number. Vertices originating from $g$ are numbered $1$ to $|V_{g}|$, whereas vertices from $h$ are numbered starting with $|V_{g}|+1$. Thus, given only $g$ and $h$ we know the vertex numbers in $g[e/h]$ without the need to explicitly compute the edge replacement. Moreover, this still applies when there are other nonterminal edges in $g$ that are derived before $e$. Assume there are nonterminal edges $e_{1},\ldots,e_{n}$ which are derived before $e$. For an edge $e_{i}$ ($1\leq i\leq n$) let $V_{i}$ be the set of internal vertices in $\mathsf{val}(A_{i})$ where $A_{i}$ is the label of $e_{i}$. Then the first available vertex number in the replacement of $e$ is $|V_{g}|+|V_{1}|+\cdots+|V_{n}|$. Doing this recursively along the path of the derivation tree allows us, given a node $u$ in $\mathsf{dt}(G)$ and a vertex $x$ in $g_{u}$, to compute the number of the vertex represented by $x$ in $\mathsf{val}(G)$. Formally we let $u$ be a node in the derivation tree $\mathsf{dt}(A)$ for some nonterminal $A$ and define a mapping between tuples $(u,x)$ and the internal vertices of $\mathsf{val}(A)$. For a nonterminal $B$ we let $\mathsf{i\text{-}nodes}(B)$ be the number of internal vertices in $\mathsf{val}(B)$. We recursively define $\mathsf{first}(u)$ as $\mathsf{first}(u)=0$ if $u=\varepsilon$ and if $u=v.i$ for some $i\in\mathbb{N}$ and $E^{\mathsf{nt}}_{g_{u}}=\{e_{1},\ldots,e_{n}\}$ with $e_{1}\leq_{\mathsf{dt}}\cdots e_{n}\mathsf{sib}(E_{g_{u}}^{\mathsf{nt}})=(e_{1},\ldots,e_{n})$ then we define the offset

[TABLE]

Now we define

[TABLE]

for any internal vertex $x$ in $g_{u}$, which represents the vertex within $\mathsf{val}(A)$. Figure 5 shows an example of a derivation tree with the root-node labeled by $S$ and its left child labeled by $A\to\mathsf{rhs}(A)$. The Figure also includes a specific example for the $\mathsf{vertex}$-mapping (vertex 1 in context $u_{4}$). Its full computation is as follows:

[TABLE]

Thus the vertex $1$ in $\mathsf{rhs}(C)$ represents the vertex $6$ in $\mathsf{val}(G)$. Do note that the same node $u$ given as a Dewey-address may refer to different nodes if evaluated on different trees, e.g. for two nonterminals $A$ and $B$ the address $u$ will refer to different nodes in $\mathsf{dt}(A)$ and $\mathsf{dt}(B)$, assuming it is valid in both. The value $\mathsf{first}(u,x)$ can therefore change when referring to different trees. It should always be clear from context on which tree this mapping is evaluated. In our final algorithm it is always $\mathsf{dt}(G)$.

4 Traversal of graphs represented by SL HR grammars

Let us clarify what we mean by traversing a graph. Let $g$ be a graph, $x\in V_{g}$ a vertex, and $e\in E_{g}$ a hyperedge attached to $x$. Let $k$ such that $\mathsf{att}_{g}(e)[k]=x$, and $l\in[\mathsf{rank}(e)]$. The operation we wish to support is $\mathsf{traverse}_{k,l}(x,\sigma)=y$ where $\sigma=\mathsf{lab}_{g}(e)$ and $y=\mathsf{att}_{g}(e)[l]$. Figure 7 shows a schematic example of this operation. We call this operation a traversal step and refer to the vertices $x$ and $y$ as $\sigma$-$k$-$l$-neighbors. We therefore are not looking for random access, but instead, given a node, we wish to traverse to one of its neighbors. Note that in a unique-labeled graph every vertex $x$ only has at most one $\sigma$-$k$-$l$-neighbor for any combination of $\sigma$, $k$, and $l$. Further note that for “regular” directed edges only one of the numbers $k$ and $l$ is really needed, as there are only two valid combinations: a $1$-$2$-neighbor is a successor of the current node, and a $2$-$1$-neighbor a predecessor. The more general notation used here is to allow for any traversal along hyperedges of higher rank.

For a grammar $G$ we wish to traverse $\mathsf{val}(G)$ in this fashion, but without explicitly computing $\mathsf{val}(G)$. We explain how using an example and intuitively define the necessary notions along the way. Figure 8 contains the graph $\mathsf{val}(G)$ on the right and one branch of the derivation tree $\mathsf{dt}(G)$ on the left. Consider first $\mathsf{val}(G)$: starting from vertex $1$, we intend to follow the $a$-edge once and then the $b$-edge twice. The appropriate traversal steps are indicated by annotations. We next explain for each of these traversal steps, how they can be recovered in $\mathsf{dt}(G)$. In a first step we need to find the vertex that represents vertex $1$ in $\mathsf{val}(G)$, which is found immediately in the start graph: $\mathsf{vertex}(u_{1},1)=1$. We next extend the $\mathsf{traverse}$-mapping to rules of a grammar. For a nonterminal $A$ and a vertex $x$ in $\mathsf{rhs}(A)$ the mapping $\mathsf{traverse}_{k,l}(A,x,\sigma)$ intuitively points us to the vertex $y$ within a node label of the derivation tree $\mathsf{dt}(A)$ such that the vertices represented by $x$ and $y$ in $\mathsf{val}(A)$ are $\sigma$-$k$-$l$-neighbors. In our example the mapping $\mathsf{traverse}_{1,2}(S,1,a)$ points towards the vertex $1$ in the node $u_{4}$ of $\mathsf{dt}(S)$. Note that the arrow visualizing this mapping is drawn in such a way, as to also visualize how this vertex is found: from vertex $1$ in $u_{1}$ we “enter” the $A$-rule and then the $C$-rule from their first external vertices each until the edge labeled $a$ is found. Thus, the mapping $\mathsf{traverse}_{1,2}(S,1,a)=(u_{4},1)$, i.e., it returns a vertex specified by a tuple consisting of a node in $\mathsf{dt}(S)$ and a vertex in $g_{u_{4}}$. To conclude the traversal step we compute $\mathsf{vertex}(u_{4},1)=6$, which is the vertex number in $\mathsf{val}(G)$.

The next step starts at vertex $(u_{4},1)$ and we intend to follow the $b$-edge. We begin in the same way as in the previous step: “entering” the $D$-rule from its first external vertex and following the edge labeled $b$ we arrive at vertex $(u_{5},1)$. However, this is not quite how the $\mathsf{traverse}$-mapping should be defined in this case: There may be multiple nodes in the derivation tree labeled $C\to\mathsf{rhs}(C)$. And since the grammar is straight-line all of these nodes have the same children, and thus should have the same result for $\mathsf{traverse}_{1,2}(C,1,b)$. Therefore $\mathsf{traverse}_{1,2}(C,1,b)$ should map to a Dewey address relative to the derivation tree $\mathsf{dt}(C)$. Since the $D$-node is the first (and only) child of the $C$-node its Dewey address within $\mathsf{dt}(C)$ is $1$ and thus $\mathsf{traverse}_{1,2}(C,1,b)=(1,1)$. As we know that we started the traversal step in vertex $(u_{4},1)$ we can recover the node relative to $\mathsf{dt}(S)$ in this way, by concatenating the relative address to $u_{4}$ and the position after two traversal steps is the vertex $(u_{4}.1,1)$ with $\mathsf{vertex}(u_{4}.1,1)=\mathsf{vertex}(u_{5},1)=7$.

Finally, we wish to follow one more $b$-edge starting at $(u_{5},1)$. Finding the neighboring vertex is easy in this case, since the $b$-edge is found in the same rule. Therefore $\mathsf{traverse}_{1,2}(D,1,b)=(\varepsilon,3)$, i.e., the vertex $(u_{5},3)$. However, this vertex is external. As an external vertex does not directly represent a vertex of $\mathsf{val}(G)$ the final step is to find the internal vertex it is merged with. Fortunately, this can always be found in an ancestor within the derivation tree. As we can see in Figure 8 (green dashed arrow) the vertex is merged first with $(u_{4},3)$ and then with $(u_{2},2)$, which is internal. Therefore we define $\mathsf{internal}(u_{5},3)=(u_{2},2)$ and in general $\mathsf{internal}(u,x)=(v,y)$ where $u$ is a node of the derivation tree, $x$ is a vertex in $g_{u}$, $v$ is an ancestor of $u$ and $y$ the internal vertex in $g_{v}$ that is merged with $x$ during derivation. If $x$ already is an internal vertex, we just let $\mathsf{internal}(u,x)=(u,x)$.

We can formally define the $\mathsf{traverse}$-mapping recursively in the following way:

$\mathsf{traverse}_{k,l}(A,x,\sigma)=(\varepsilon,y)$, if there exists $e\in E_{\mathsf{rhs}(A)}$ with $\mathsf{att}(e)[k]=x$, $\mathsf{att}(e)[l]=y$ and $\mathsf{lab}(e)=\sigma$.

• 2.

$\mathsf{traverse}_{k,l}(A,x,\sigma)=(v.i,y)$ if $x=\mathsf{att}(e_{i})[j]$ and $\mathsf{traverse}(\mathsf{lab}(e_{i}),\mathsf{ext}_{\mathsf{rhs}(\mathsf{lab}(e_{i}))}[j],\sigma)=(v,y)$.

Note that this definition implies the mapping can be precomputed for every combination of $A$, $x$, and $\sigma$ by one bottom-up (i.e., in reverse $\leq_{\mathsf{NT}}$) pass of the grammar. A similar definition can be given of the aforementioned $\mathsf{i\text{-}nodes}(A)$, which is the number of internal nodes in $\mathsf{val}(A)$ for a nonterminal $A$. This mapping can be defined as $\mathsf{i\text{-}nodes}(A)=\sum\{\mathsf{i\text{-}nodes}(\mathsf{lab}(e))\mid e\in E^{\mathsf{nt}}_{\mathsf{rhs}(A)}\}+|V_{\mathsf{rhs}(A)}|-|\mathsf{ext}_{\mathsf{rhs}(A)}|$ which also allows for a bottom-up computation in one pass.

In summary, to traverse a $\sigma$-edge that is attached at index $k$ to $\mathsf{vertex}(u,x)$ in $\mathsf{val}(G)$ towards the node attached at index $l$ we

compute $\mathsf{traverse}_{k,l}(A_{u},x,\sigma)=(v^{\prime},y^{\prime})$, 2. 2.

let $w=u.v^{\prime}$ be the address of the node containing $y^{\prime}$ in its label with respect to $\mathsf{dt}(G)$, 3. 3.

compute $\mathsf{internal}(w,y^{\prime})=(v,y)$, and 4. 4.

compute $\mathsf{vertex}(v,y)$.

In Section 4.2 below we introduce a data structure that allows us to do each of these steps in constant time for unique-label SL-HR grammars of bounded rank. This is our main result.

4.1 Delay of naive implementation and other approaches

For the methods outlined in the introduction to Section 4 the delay of a naive implementation can only be given as $O(0pt(G))$. It is not hard to construct a grammar (e.g. Figure 9) where every step from one node to another corresponds to a step from the root to a leaf in the derivation tree (or vice versa), and thus the time needed to compute $\mathsf{internal}$ or $\mathsf{traverse}$ for this grammar is $O(0pt(G))$.

For straight-line programs (context-free string grammars with the straight-line restriction), or SLPs, it is known that one traversal step (here: going from one symbol to the next) can be done in constant time using linear time/space preprocessing [11]. This works by visiting the leafs of the derivation tree of an SLP in order, which results in the string represented. A data structure based on tries is used to guarantee that the move from one leaf of the derivation tree to the next can always be done in constant time. The data structure solves the “next link problem” in constant time. For a given leaf $u$ this problem asks for the node $w$ and the number $k$ such that $u$ is in the $k$-th subtree of $w$ and the next leaf $v$ is in the $(k+1)$-th subtree of $w$, i.e., $w$ is the lowest common ancestor (LCA) of $u$ and $v$. This operation can be carried out in constant time (after linear-time preprocessing) using any of several well-known tree indexing data structures (e.g. a variant of finding LCA [25] described in the book [12], or over first-child/next-sibling encoded binary trees, with simple and efficient LCA structures [3] — cf. the discussion at the end of the article [18]). The article [18] further generalizes the method to SL tree grammars provided the grammar is given in a normal form, which structures the derivation into “string-like” parts that are branched off from. It is unlikely that this method generalizes to SL-HR grammars for at least two reasons: first there is a major difference in the grammar formalisms. In string and tree grammars the objects that are traversed (consecutive symbols of the string, nodes in the tree) are also the terminals of the grammar. In HR grammars however, terminals and nonterminals are (hyper-)edges of the graph, but we wish to traverse the graph’s vertices along the edges. An important effect is that it is not reasonably possible to confine the objects of interest (i.e., the vertices) to the leafs of the derivation tree. Such a restriction would be very strong and would make it impossible to, for example, construct a grammar that represents a string graph of $2^{n}$ consecutive $a$-edges with a grammar of $O(n)$ size. It can therefore be assumed that traversal of the represented graph requires navigation on arbitrary nodes in the derivation tree, instead of only navigating from leaf to leaf. Furthermore, as we see in the example discussed in the introduction to Section 4, traversing from one vertex in $\mathsf{val}(G)$ to another may incur “jumps” in the derivation tree, i.e., the navigation in the derivation tree is not restricted to single parent/child steps, but may require longer paths.

4.2 Tableaux and how to use them

We seek a data structure that allows to compute, in constant time, each of the three operations $\mathsf{traverse}$, $\mathsf{internal}$, and $\mathsf{vertex}$, and which can be precomputed in polynomial time. The data structure we construct in the following essentially achieves this by precomputing $\mathsf{internal}$ and $\mathsf{first}$ for every valid $\mathsf{traverse}$-input. To get an intuitive understanding of this, we first make some more observations about the example from Figure 8 above and then extend the example with our data structure. We then define it and explain how it is built afterwards.

We note the following property of $\mathsf{traverse}$ and $\mathsf{internal}$ that will be important: starting from a node $u$ in the derivation tree, $\mathsf{traverse}$ will always lead to a successor of $u$, whereas $\mathsf{internal}$ will always lead to an ancestor. Neither mapping ever branches to a sibling. For the traversal we therefore need to maintain a structure that represents only one branch of the derivation tree. As we already observed before, we can compute $\mathsf{traverse}(A,\sigma,x)$ for any combination of $A$, $\sigma$, and $x$ by considering only $\mathsf{dt}(A)$, i.e., a subtree of $\mathsf{dt}(S)$. This yields a branch of $\mathsf{dt}(A)$ which we can concatenate with the current branch of $\mathsf{dt}(S)$ to get the full branch for the target vertex (compare $\mathsf{traverse}_{1,2}(C,1,b)$ in the above example). Since $\mathsf{traverse}$ only depends on $\mathsf{dt}(A)$ and there are at most $|N||\Sigma||G|$ possible combinations of $A$, $\sigma$, and $x$ these “partial branches” can be precomputed in polynomial time. This is the core of our data structure: we model every partial branch using a matrix (we call it a “tableau”) of pointers, where each row of the matrix corresponds directly to a node in the branch and each column corresponds to the external vertices. The intention is that a cell – again, row and column denote a node $v$ and external vertex within $g_{v}$ – has a pointer to another cell which contains the internal vertex that is merged with the external vertex the first cell refers to. The immediate problem is, that while $\mathsf{traverse}$ is defined exclusively with relation to $\mathsf{dt}(A)$, $\mathsf{internal}$ is only valid on full branches of $\mathsf{dt}(S)$ since the internal vertex merged with an external vertex may be in any ancestor within the derivation tree. Compare again the above example in Figure 8: here $\mathsf{internal}(u_{5},3)=(u_{2},2)$, but we actually reached $u_{5}$ by traversing from a vertex in $u_{4}$ using $\mathsf{traverse}_{1,2}(C,1,b)$. We thus cannot precompute the full mapping if we only consider $\mathsf{dt}(C)$. The solution is simple: we precompute as much of it as we can, and when concatenating a partial branch with the current full branch of $\mathsf{dt}(S)$ we connect the ends. Similarly for $\mathsf{first}$: for any $\mathsf{traverse}(A,\sigma,x)$ we precompute $\mathsf{first}$ relative to $\mathsf{dt}(A)$, and then add an appropriate offset once the branches are concatenated.

To exemplify these intuitions, let us consider how our proposed data structure would handle the example from Figure 8. Figure 10 contains the branch of the derivation tree next to two matrices which model the branches $\mathsf{traverse}_{1,2}(S,1,a)$ and $\mathsf{traverse}_{1,2}(C,1,B)$, respectively. Both matrices have additional annotations $\mathsf{nt}$ and $\mathsf{first}$, and we usually refer to the entire structure (with the additional annotations) as a “tableau”. Consider first the upper tableau $t_{1}$. It models the branch $u_{4}=1.2$ of the derivation tree $\mathsf{dt}(G)$ which is what we need for $\mathsf{traverse}_{1,2}(S,1,a)$. Each of the tableau’s three rows directly corresponds to one of the nodes in the derivation tree (denoted by light gray lines). Every cell of the main matrix of the tableau is split into two parts: a pointer $\mathsf{nxt}$ and a number $\mathsf{vtx}$. We explain in the following how this tableau is used to determine $\mathsf{vertex}$ and $\mathsf{internal}$. To compute the vertex number of vertex $1$ in node $u_{4}$ with respect to $\mathsf{val}(G)$ we can use the $\mathsf{first}$-values provided by the tableau: the third row corresponds to $u_{4}$ and has $\mathsf{first}=5$. Thus $\mathsf{vertex}(u_{4},1)=5+1=6$, just as discussed previously. Analogously, if we wanted to determine the vertex number of vertex $2$ in node $u_{2}$ we would use the $\mathsf{first}$-value in the second row of the tableau, which is $2$ and thus $\mathsf{vertex}(u_{2},2)=2+2=4$. The other information we can take from the tableau is the $\mathsf{internal}$-mapping. In Figure 10 we denoted by a dashed green edge the mapping $\mathsf{internal}(u_{4},3)$, which is the second external vertex of the graph $\mathsf{rhs}(C)$. Consequently we find, in the second column of the third row of $t_{1}$, an edge (also colored green) pointing to a cell in the row above. This cell has a $\mathsf{vtx}$-value of $2$, which tells us that the vertex $2$ in the node corresponding to the second row (i.e., $u_{2}$) is the internal vertex merged with this external vertex. The reader may have noticed that some arrows in the tableau point to rows below instead of above, which contradicts the previous intuition that the $\mathsf{internal}$-mapping always points to an ancestor in the derivation tree. We will explain the reason for this in the next paragraph, but for now already mention the rules for these arrows:

An arrow going up (we speak of an upwards pointer) always ends at a cell with a $\mathsf{vtx}$-value containing the number of the vertex that is merged with the external vertex corresponding to the start of the arrow. If such a vertex does not exist within the scope of the tableau, the pointer instead ends at the cell of the first row representing the external vertex the current vertex is merged with.

• 2.

An arrow going down (we refer to these as downwards pointers) always ends at a cell containing an upwards pointer, which, when followed, leads to the correct internal vertex that is merged with the external vertex at either arrows end.

Thus there are two cases for computing the $\mathsf{internal}$-mapping using the tableau: if $\mathsf{nxt}$ contains an upwards pointer, we follow it and are done. If $\mathsf{nxt}$ contains a downwards pointer, we follow it and also the upwards pointer at its end. This way, after at most 2 steps, we always end at the correct position.

We did not yet mention the second tableau $t_{2}$ in Figure 10. It is built in the same way as $t_{1}$, and correctly models the branch of the derivation tree relevant for $\mathsf{traverse}_{1,2}(C,1,b)$, with respect to $\mathsf{val}(C)$. In $\mathsf{val}(C)$ the external vertices of $\mathsf{rhs}(C)$ are never merged with any other node, therefore all three $\mathsf{nxt}$ pointers in the first row of $t_{2}$ are cyclic. If a $\mathsf{nxt}$ pointer just cycles back to the origin (even if that happens in two steps as is the case for the second external vertex here), this means that there is no internal vertex in the scope of this tableau merged with the external vertex. Note that this can never happen for full branches of $\mathsf{dt}(S)$, since the start graph is defined to be of rank [math]. This behavior matches the definition of $\mathsf{traverse}_{1,2}(C,1,b)$ which gives a Dewey address relative to $\mathsf{dt}(C)$. Just like this address is concatenated with the one of the initial node ($u_{4}$ in our example), the tableau $t_{2}$ needs to be “concatenated” to $t_{1}$ to model the entire branch of the derivation tree. The result of this process can be seen in Figure 11. Since both the last row of $t_{1}$ and the first row of $t_{2}$ correspond to the same node in the derivation tree we can simply connect them column-wise. Herein lies the reason for the existence of downwards pointers: they occur if more than one external vertex within the branch merges with the same internal vertex. To make sure that in these cases we only ever have to change one pointer when concatenating two tableaux, we use the two types of pointers and only need to change the upwards pointer (seen here in the second column of $t_{2}$). Otherwise the time to concatenate two tableaux could not be bounded by $O(\kappa)$. One more addition needs to be made at this point. The $\mathsf{first}$ values in $t_{2}$ are given with respect to $\mathsf{dt}(C)$. The final part of the tableau-data structure is thus an offset value. When concatenating $t_{2}$ to $t_{1}$, we use the $\mathsf{first}$-value of the last row in $t_{1}$ (and any offset it may already have) as the offset in $t_{2}$. This ensures that the last row of $t_{1}$ and the first row of $t_{2}$ have the same $\mathsf{first}$ values, which should be the case as they both represent the same node. In Figure 11 we can thus see that $\mathsf{internal}(u_{5},3)$ is correctly modeled by the concatenated tableaux (green arrows) and that $\mathsf{vertex}(u_{5},1)$ can be correctly computed using the $\mathsf{first}$-value of the corresponding row in $t_{2}$ (its last row) and the offset: $\mathsf{vertex}(u_{5},1)=1+1+5=7$. We invite the reader to check that the other external vertices are also correctly mapped to their internal equivalents.

4.3 Precomputing Tableaux

In this section we will explain how to precompute the necessary tableaux in advance, but first let us formalize their definition following the description in the previous section. We begin by defining an auxiliary function to streamline how the tableau is used to support the $\mathsf{internal}$ mapping. As detailed in the previous section, we always follow one or two $\mathsf{nxt}$ pointers depending on whether the first one was downwards or not. Let $t(i,j)$ be the cell at row $i$ and column $j$ of the matrix $t$. We then use $\mathsf{nxt}(t(i,j))=t^{\prime}(i^{\prime},j^{\prime})$ to refer to the cell referenced by the $\mathsf{nxt}$ pointer in $t(i,j)$, i.e., the $\mathsf{nxt}$ pointer in cell $(i,j)$ of $t$ references the cell $(i^{\prime},j^{\prime})$ of $t^{\prime}$. We formalize the distinction between upwards and downwards pointers we introduced above: we call $\mathsf{nxt}$ an upwards pointer if $t^{\prime}\neq t$ or $t^{\prime}=t$ and $i^{\prime}\leq i$ and a downwards pointer if $t^{\prime}=t$ and $i^{\prime}>i$. Then we define $\mathsf{findVertex}(t(i,j))$ as

[TABLE]

This function always maps to the cell containing the internal vertex merged with the $j$-th external vertex of row $i$. As with the $\mathsf{nxt}$ pointer, we use $\mathsf{vtx}(t(i,j))$ to reference the vertex number given in the cell $t(i,j)$. Thus the number of the internal vertex merged with the $j$-th external vertex of row $i$ is $\mathsf{vtx}(\mathsf{findVertex}(t(i,j)))$. We formally define the properties of a tableau:

Definition 4.1**.**

Let $A$ be a nonterminal, let $u_{m}$ be a node in $\mathsf{dt}(A)$, and let $u_{1},u_{2},\ldots,u_{m-1}$ be the nodes on the path from the root of $\mathsf{dt}(A)$ ($=u_{1}$) to $u_{m}$. For any $i\in[m]$ let $u_{i}$ be labeled with $A_{i}\to g_{i}$. Then $\mathsf{tab}(u_{m})$ is any tuple $(t,t^{\mathsf{nt}},t^{\mathsf{first}},t^{\mathsf{off}})$ where $t$ is an $m\times\kappa$ matrix, $t^{\mathsf{nt}}$ and $t^{\mathsf{first}}$ are $m$ column-vectors, $t^{\mathsf{off}}$ is a number, and for every $i\in[m]$ the following properties are fulfilled:

$t^{\mathsf{nt}}(i)=A_{i}$ 2. 2.

$t^{\mathsf{first}}(i)=\mathsf{first}(u_{i})$ (with respect to $\mathsf{dt}(A)$) 3. 3.

For $j\in[\mathsf{rank}(A_{i})]$ let $y$ be the $j$-th external vertex of $g_{i}$. The cells of $t$ are filled such that they fulfill the following conditions:

1. (a)

$\mathsf{internal}(u_{i},y)=(u_{r},z)$ where $u_{r}$ is an ancestor of $u_{i}$ in $\mathsf{dt}(A)$ (i.e., $r\leq i$). Then $\mathsf{findVertex}(t(i,j))=t(r,j^{\prime})$ for some $j^{\prime}$ and $\mathsf{vtx}(t(r,j^{\prime}))=z$. 2. (b)

$\mathsf{internal}(u_{i},y)$ is undefined. Then $\mathsf{findVertex}(t(i,j))=t(1,j^{\prime})$ for some $j^{\prime}$ and $\mathsf{vtx}(t(1,j^{\prime}))=0$. 3. (c)

The pointer $\mathsf{nxt}(t(i,j))$ is an upwards pointer if and only if there is no $i^{\prime}>i$ and $j^{\prime}$ such that $\mathsf{findVertex}(t(i,j))=\mathsf{findVertex}(t(i^{\prime},j^{\prime}))$. 4. (d)

Unless otherwise specified by the above conditions, $\mathsf{nxt}$ and $\mathsf{vtx}$ for a cell are [math]. 4. 4.

$t^{\mathsf{off}}=0$

This definition specifies the informal definition of the previous section: There is one row per ancestor of $u_{m}$, each with appropriate nonterminal, and $\mathsf{first}$-values (items 1 and 2 in the definition). Further, the cells are specified to contain tuples of $(\mathsf{nxt},\mathsf{vtx})$ such that the internal vertex merged with a given external vertex is found in at most two steps (item 3). We say that such a tableau models the path from the root of $\mathsf{dt}(A)$ to the node $u_{m}$, or simply the tableau models $u_{m}$. Note that, while a tableau $t$ by this definition models the node $u_{m}$, its first $i$ rows also model its ancestor $u_{i}$ for any $i\in[m]$. A tableau thus can be interpreted as an encoding of a specific branch of the derivation tree. The tableau for a traversal step is consequently defined as the tableau modeling the path in the derivation tree:

Definition 4.2**.**

For a given nonterminal $A$, node $x$ in $\mathsf{rhs}(A)$, edge label $\sigma$ and indices $k,l$ let $\mathsf{traverse}_{k,l}(A,x,\sigma)=(u,y)$. Then we define the tableau $\mathsf{tab}_{k}(A,x,\sigma)=\mathsf{tab}(u)$.

We precompute the tableaux for every possible combination of nonterminal $A\in N$, label $\sigma\in\Sigma$, vertex $x\in V_{\mathsf{rhs}(A)}$, and outgoing neighbor index $k$. It is not necessary to specify the incoming neighbor index $l$ at this point: let $l$ and $r$ be two different such indices, then $\mathsf{traverse}_{k,l}(A,x,\sigma)=(u,y)$ and $\mathsf{traverse}_{k,r}(A,x,\sigma)=(u,y^{\prime})$. So while the vertex component of the tuples is different, in both cases the same node of the derivation tree is referenced. Since the tableaux only represent the nodes of the derivation tree both traversals can be represented by the same tableau. The tableaux are computed inductively using Algorithm 1. For any given nonterminal $A$ we can represent the root node of $\mathsf{dt}(A)$ using the tableau $(t_{\varepsilon},(A),(0),0)$ where $t_{\varepsilon}$ is a $1\times\kappa$ matrix with

$\mathsf{nxt}(t_{\varepsilon}(1,j))=t_{\varepsilon}(1,j)$ for $j\leq\mathsf{rank}(A)$

• 2.

$\mathsf{nxt}(t_{\varepsilon}(1,j))=0$ for $j>\mathsf{rank}(A)$, and

• 3.

$\mathsf{vtx}(t_{\varepsilon}(1,j))=0$ for all $j$.

This generates upwards pointers for every external vertex of $\mathsf{rhs}(A)$, but since $A\to\mathsf{rhs}(A)$ is the root of $\mathsf{dt}(A)$ these pointers just loop back to their origin. Note that this tableau models the path consisting only of the root of $\mathsf{dt}(A)$ by Definition 4.1. Starting from this, the tableau $\mathsf{tab}_{k}(A,x,\sigma)$ is constructed row by row, such that every intermediate step is a valid tableau modeling the path in the derivation tree up to that point. Assume therefore, that we already have a tableau modeling the path to $v$ in $\mathsf{dt}(A)$, and we wish to extend it to model $u$, which is a child of $v$. This situation is illustrated in Figure 12. The derivation tree $\mathsf{dt}(A)$ is on the left of the figure, the nodes $v$ and $u$ are expanded with their labels ($B\to g_{v}$ and $C\to g_{u}$, respectively), though only the relevant parts of the graphs $g_{v}$ and $g_{u}$ are shown. The external vertices of $g_{u}$ are connected by colored lines with the vertices in the parent node $v$ they are merged with. Information on the ancestors of $v$ is not necessary for the extension of the tableau $t_{v}$ and therefore left out of the figure. The bottom row of the tableau $t_{v}$ is shown on the upper right of the figure. Even though only the bottom row is shown, we can deduce some information on the external vertices of $g_{v}$ from the $\mathsf{nxt}$ pointers in it: namely that the first two external vertices (the ones numbered 2 and 3 in $g_{v}$) are merged with other external vertices in the parent of $v$, whereas the third external vertex (numbered 4) is merged with an internal vertex. We know this, because the first two columns have incoming downwards pointers, whereas the third one does not. Recall that downwards pointers are only used to denote that more than one external vertex is merged with the same internal vertex. The bottom right of the figure shows the tableau $t_{u}$, which is the result of Algorithm 1 with input $A$ and $u$. We now explain how the algorithm extends $t_{v}$ to obtain $t_{u}$ (lines 10 to 29 of the algorithm).

To extend $t_{v}$ such that the resulting tableau models $t_{u}$, we need to add a row to the matrix $t_{v}$, and elements to $t_{v}^{\mathsf{nt}}$ and $t_{v}^{\mathsf{first}}$. We focus on the former for now, since extending the vectors $t_{v}^{\mathsf{nt}}$ and $t_{v}^{\mathsf{first}}$ is comparatively straightforward. We let $u$ be the $l$-th child of $v$. Thus $v$ has at least $l$ nonterminal edges, and we let $e_{l}$ be the $l$-th one by the derivation order. To now extend $t_{v}$ into $t_{u}$ we need to make sure the $\mathsf{nxt}$ pointers on the newly added last row all correctly represent the external vertices of $u$. Doing this may involve making changes to already existing $\mathsf{nxt}$ pointers in the rows above, if an external vertex of $u$ is merged with an external vertex of $v$. Let $y$ be the $j$-th external vertex of $g_{u}$. During derivation it is merged with the $j$-th vertex attached to $e_{l}$, which we name $x$ (cf. line 16 in Algorithm 1). There are now two possible cases: $x$ could be internal or external. The simpler case is, if $x$ is internal. Then we add a $\mathsf{nxt}$ pointer in column $j$ of the last row to reference the same column in the row above. The $\mathsf{vtx}$ element of that cell is further set to contain the vertex number of $x$. In Figure 12 this happens for the first ($j=1$) external vertex (orange color). Lines 19 and 20 in Algorithm 1 handle this case. In the second case $x$ is itself an external vertex. Therefore both $x$ and $y$ ultimately represent the same internal vertex found in an ancestor of $v$. In this case we intuitively move the entire cell of representing $x$ in $t_{v}$ to the cell representing $y$ in $t_{u}$ and add one downwards pointer “from $x$ to $y$”. This way $\mathsf{findVertex}$ yields the same result in both cases and Condition 3 of Definition 4.1 is preserved. In Figure 12 this happens for the second and third external vertices of $u$ (colored green and blue). We encourage the reader to verify that lines 22 to 26 of Algorithm 1 have exactly this effect on $t_{u}$ in Figure 12. As previously mentioned, extending $t_{v}^{\mathsf{nt}}$ and $t_{v}^{\mathsf{first}}$ is straightforward by comparison: $t_{v}^{\mathsf{nt}}$ is extended by one element containing $C$ since that is the nonterminal in the label of $u$. The element added to $t_{v}^{\mathsf{first}}$ is the sum of

the last element of $t_{v}^{\mathsf{first}}$ ($c_{v}$ in Figure 12), 2. 2.

the number of internal vertices in $g_{v}$, and 3. 3.

the sum of internal vertices generated by the $l-1$ nonterminal edges in $v$ that are derived before $e_{l}$.

This sum equates to the definition of $\mathsf{first}(u)$. Algorithm 1 computes this sum in line 28.

We can now prove Algorithm 1 correct in the following sense:

Lemma 4.3**.**

For $A\in N$, $x\in V_{\mathsf{rhs}(A)}$, $\sigma\in\Sigma$, and indices $k,l$ let $\mathsf{traverse}_{k,l}(A,x,\sigma)=(u,y)$. Then the tableau $t=\mathsf{createTableau}(A,u)$ computed by Algorithm 1 equals the tableau $\mathsf{tab}_{k}(A,x,\sigma)$ as defined in Definition 4.2.

Proof.

To prove the claim it suffices to show that $t$ models the path to $u$ in $\mathsf{dt}(A)$ as defined in Definition 4.1, since $\mathsf{tab}_{k}(A,x,\sigma)=\mathsf{tab}(u)$. We prove this inductively over $u$. For $u=\varepsilon$ the tableau $t_{\varepsilon}$ obviously $\mathsf{dt}(A)$-models $u$. Otherwise $u$ can be expressed as $u=v.l$ for some $l\in\mathbb{N}$. Let the labels of $v$ and $u$ be $B\to g_{v}$ and $C\to g_{u}$, respectively. By induction we obtain $t_{v}$, which models the path from the root of $\mathsf{dt}(A)$ to $v$. Let $t_{v}$ have $m$ rows, and let $t_{u}$ be the $n=m+1$ row tableau computed by extending $t_{v}$ using Algorithm 1. Then $t_{u}$ is correct according to Definition 4.1: Condition 1 of the definition obviously holds. As previously noted, Line 28 of Algorithm 1 is just the definition of $\mathsf{first}(u)$, thus condition 2 is also fulfilled. This leaves condition 3. Let $j\in[\mathsf{rank}(C)]$ and let $x$ be defined as in Line 16 of Algorithm 1. If $x$ is internal then $\mathsf{findVertex}(t_{u}(m,j))$ fulfills condition 3 by induction and $\mathsf{findVertex}(t_{u}(n,j))$ correctly references the cell containing $x$ by Line 20 of the algorithm. If otherwise $x$ is external then let $\mathsf{internal}_{\mathsf{dt}(A)}(v,x)=(w,y)$ and let $x$ be the $j^{\prime}$-th external node of $g_{v}$. By induction $\mathsf{findVertex}(t_{v}(m,j^{\prime}))$ references a cell $c$ in the row representing $w$ of $t_{v}$, which contains $y$ as its $\mathsf{vtx}$-part. Note that it has to be an upwards pointer, because there is no row below $m$ in $t_{v}$. After Line 26 of the algorithm $\mathsf{nxt}(t_{u}(n,j))=c$ is an upwards pointer and every downwards pointer previously pointing to $t_{u}(m,j)$ now instead points to $t_{u}(n,j)$ and thus has the same $\mathsf{findVertex}$-result as before (i.e., $c$). The same argument holds if $\mathsf{internal}_{\mathsf{dt}(A)}(v,x)$ is undefined, where $t_{v}(m,j^{\prime})$ is some cell in the first row of $t_{v}$. Finally, $t^{\mathsf{off}}=0$ in $t_{\varepsilon}$ and remains unchanged in the further iterations of the algorithm. ∎

4.4 Concatenating tableaux

As explained in Section 4.2 above, to support arbitrary traversal, it is necessary to concatenate tableaux to model longer paths in the derivation tree. The algorithm to do so is straightforward (given in Algorithm 2). An example of this operation was already shown in Figure 11. The example is of a concatenation in the intuitive sense: $t_{2}$ is attached to $t_{1}$ at the latter’s bottom row. One could however also say that the last row of $t_{1}$ is in fact replaced by $t_{2}$. This may be a better point of view to take, because the concatenation is not always an attachment at the bottom row. Instead a tableau may be concatenated at any intermediate row. This happens when, due to a traversal ending at an external vertex, the current position within the derivation tree is not represented by the bottom row of the tableau, but instead by row $i$. If the next traversal then adds a tableau to concatenate, it needs to be concatenated to row $i$ of the first tableau to correctly model the full branch of the derivation tree. Algorithm 2 thus takes as a third parameter a row number specifying from where in $t_{1}$ to concatenate $t_{2}$. The example in Figure 11 is the result of the operation $\mathsf{concat}(t_{2},t_{1},3)$.

Concatenating a tableau $t_{2}$ with $m$ rows to a tableau $t_{1}$ at its $k$-th row results in a “virtual” tableau $t$ with $(k-1)+m$ rows. To this end we define for any $i\in\{1,\ldots,(k-1)+m\}$ and $j\in[\kappa]$ the following mappings:

[TABLE]

The intention being that we continue to use the first $k-1$ rows of $t_{1}$ as before, but virtually replace row $k$ with $t_{2}$. Using this we can show that two concatenated tableaux model a concatenated path in a derivation tree.

Lemma 4.4**.**

Let $A_{1}$ be a nonterminal, let $u_{m}$ be a node in $\mathsf{dt}(A_{1})$, and let $u_{1},\ldots,u_{m-1}$ be the nodes on the path from the root of $\mathsf{dt}(A_{1})$ to $u_{m}$. For $i\in[m]$ let $u_{i}$ be labeled by $A_{i}\to g_{i}$. Let $t_{1}$ be a tableau whose first $r$ rows model the path $u_{1},\ldots,u_{r}$ in $\mathsf{dt}(A_{1})$ and let $t_{2}$ be a tableau that models the path $u_{r},\ldots,u_{m}$ in $\mathsf{dt}(A_{r})$. Then the virtual tableau $t$ resulting of $\mathsf{concat}(t_{2},t_{1},r)$ as per Algorithm 2 models the path from $u_{1}$ to $u_{m}$ in $\mathsf{dt}(A_{1})$. Computing $\mathsf{concat}(t_{2},t_{1},r)$ takes $O(\kappa)$ time, where $\kappa$ is the maximal nonterminal rank.

Proof.

We show the conditions of Definition 4.1 to be true for $t$ (Condition 4 is trivially fulfilled).

Condition 1

As per the premise, $t_{1}^{\mathsf{nt}}(i)=A_{i}$ for $i\in[r-1]$ and $t_{2}^{\mathsf{nt}}(i-(r-1))=A_{i}$ for $i\in\{r,\ldots,m\}$. Thus $t^{\mathsf{nt}}(i)=A_{i}$ for $i\in[m]$.

Condition 2

Again, per the premise $t_{1}^{\mathsf{first}}(i)+t_{1}^{\mathsf{off}}=\mathsf{first}(u_{i})$ for $1\leq i<r$. After running $\mathsf{concat}(t_{2},t_{1},r)$ we further have $t_{2}^{\mathsf{off}}=t_{1}^{\mathsf{first}}(r)+t_{1}^{\mathsf{off}}$. It follows that $t_{2}^{\mathsf{first}}(1)+t_{2}^{\mathsf{off}}=\mathsf{first}(u_{r})$, since $t_{1}^{\mathsf{first}}(r)+t_{1}^{\mathsf{off}}=\mathsf{first}(u_{r})$ and $t_{2}^{\mathsf{first}}(1)=0$ by Definition 4.1. It follows that $t_{2}^{\mathsf{first}}(i-(r-1))+t_{2}^{\mathsf{off}}=\mathsf{first}(u_{i})$ for $i\in\{r,\ldots,m\}$ and thus $t^{\mathsf{first}}(i)+t^{\mathsf{off}}=\mathsf{first}(u_{i})$ for $i\in[m]$.

Condition 3

The tableau $t_{1}$ is unchanged by $\mathsf{concat}(t_{2},t_{1},r)$ and thus for every $i\in[r-1]$ and $j\in[\kappa]$ there exist indices $i^{\prime}\in[i]$ and $j^{\prime}\in[\kappa]$ such that $\mathsf{findVertex}(t_{1}(i,j))=t_{1}(i^{\prime},j^{\prime})$ and $\mathsf{internal}(u_{i},x)=(u_{i^{\prime}},\mathsf{vtx}(t_{1}(i^{\prime},j^{\prime})))$ where $x$ is the $j$-th external vertex of $g_{i}$.

Similarly, most of $t_{2}$ is unchanged: $t_{2}$ is constructed such that $\mathsf{findVertex}(t_{2}(i,j))$ for any $i,j$ yields the internal vertex merged with the $j$-th external vertex in the rule represented by the $i$-th row of $t_{2}$. Whenever such a node exists in $\mathsf{dt}(A_{r})$ the corresponding $\mathsf{nxt}$-pointers are unchanged. In all other cases the $\mathsf{concat}(t_{2},t_{1},r)$ operation replaces the upwards pointers in $t_{2}$ by new ones referencing cells in $t_{1}$. These cells are found by taking the $\mathsf{nxt}$-pointers of the $r$-th row of $t_{1}$, which models the node $u_{r}$ in $\mathsf{dt}(A_{1})$.

Formally let $i\in\{r,\ldots,m\}$, $j\in[\kappa]$, and let $x$ be the $j$-th external vertex of $g_{i}$. Whenever $\mathsf{internal}(u_{i},x)=(u_{i^{\prime}},y)$ such that $i^{\prime}\in\{r,\ldots,i\}$ (i.e., the target node is in $\mathsf{dt}(A_{r})$) then $\mathsf{findVertex}(t_{2}(i-(r-1),j))=t_{2}(i^{\prime}-(r-1),j^{\prime})$ with $\mathsf{vtx}(t_{2}(i^{\prime}-(r-1),j^{\prime}))=y$ by Definition 4.1.

This leaves cases where $\mathsf{internal}(u_{i},x)=(u_{i^{\prime}},y)$ such that $i^{\prime}\in[r-1]$. For this case note that before ever running a concatenation with $t_{2}$ the result of $\mathsf{findVertex}(t_{2}(i-(r-1),j))=t_{2}(1,j^{\prime})$ is the cell in the first row of $t_{2}$ representing the external vertex of $g_{r}$ merged with the $j$-th external vertex of $g_{i}$ (i.e., $x$). Both of these external vertices thus represent the same internal vertex. Further, $\mathsf{findVertex}(t_{1}(r,j^{\prime}))=t_{1}(i^{\prime},j^{\prime\prime})$ is such that $\mathsf{vtx}(t_{1}(i^{\prime},j^{\prime\prime}))=y$ since $t_{1}$ models the path from $u_{1}$ to $u_{r}$ in $\mathsf{dt}(A^{\prime})$. After line 5 in Algorithm 2 $\mathsf{findVertex}(t_{2}(i-(r-1),j))=\mathsf{findVertex}(t_{1}(r,j^{\prime}))$, and thus the condition holds in these cases as well. It follows that for every $i\in[m]$ and $j\in[\kappa]$ there exist indices $i^{\prime}\in[i]$ and $j^{\prime}\in[\kappa]$ such that $\mathsf{findVertex}(t(i,j))=t(i^{\prime},j^{\prime})$ and $\mathsf{internal}(u_{i},x)=(u_{i^{\prime}},\mathsf{vtx}(t(i^{\prime},j^{\prime})))$ where $x$ is the $j$-th external vertex of $g_{i}$.

Finally the algorithm uses one call of $\mathsf{findVertex}$ and follows one additional $\mathsf{nxt}$ pointer per column of the tableaux. Since the tableaux have $\kappa$ columns we obtain a runtime of $O(\kappa)$. ∎ Note that the argument in the proof of Lemma 4.4 still holds if $t_{1}$ is itself a “virtual tableau”. It follows that concatenations of an arbitrary number of tableaux can model a path in the derivation tree of a grammar.

4.5 Traversals using tableaux

To traverse a graph using the method outlined at the beginning of Section 4 we need to store the current node $u$ within $\mathsf{dt}(S)$. As detailed in the previous section we represent this node using a sequence of tableaux $t_{1},\ldots,t_{n}$. However as these tableaux are all chained together via Algorithm 2, we only need to store a pointer to $t_{n}=\mathsf{tab}(A,x,\sigma)$ for some $A\in N$, $x\in\mathsf{rhs}(A)$ and $\sigma\in\Sigma$. We call this pointer $\mathsf{cTab}$. As tableaux usually represent more than one node in the derivation tree we further need a row index to mark which row of the tableau actually represents $u$. We call this index $\mathsf{pos}$. Finally our current position is a vertex $y\in g_{u}$, which we call $\mathsf{cNode}$. To find the matching internal vertex of a node $x\in g_{u}$ let $\mathsf{internal}(x,\mathsf{cTab},\mathsf{pos})=(x,\mathsf{cTab},\mathsf{pos})$ if $x$ is internal. Otherwise let $x$ be the $j$-th external vertex of $g_{u}$ and let $c=\mathsf{findVertex}(\mathsf{cTab}(\mathsf{pos},j))$ be a cell in the $j^{\prime}$-th row of $\mathsf{tab}(A,y,\sigma)$ for some $A\in N$, $y\in\mathsf{rhs}(A)$, and $\sigma\in\Sigma$. Then $\mathsf{internal}(x,\mathsf{cTab},\mathsf{pos})=(\mathsf{vtx}(c),\mathsf{tab}(A,y,\sigma),j^{\prime})$.

Theorem 4.5**.**

Given a unique-labeled SL HR grammar $G=(N,P,S)$ of bounded rank $\kappa$, height $h$, and maximal terminal rank in $\mathsf{val}(G)$ of $r$ we can traverse the edges of the graph $\mathsf{val}(G)$ starting from any node in the start graph with $O(\kappa)$ time per traversal step. The precomputation uses $O(|G||\Sigma|\kappa h^{2}r)$ time and $O(|G||\Sigma|\kappa hr)$ space.

Proof.

Let $M$ be the largest vertex number appearing in $G$. For any $A\in N$, $x\in[M]$, $\sigma\in\Sigma$, and $k,l\in[\mathsf{rank}(\sigma)]$ we precompute the tableaux $\mathsf{tab}_{k}(A,x,\sigma)$ (if defined, i.e., $x$ exists in $\mathsf{rhs}(A)$) and for $\mathsf{traverse}_{k,l}(A,x,\sigma)=(v,y)$ we define $\mathsf{succ}_{k,l}(A,x,\sigma)=y$, which is also stored during the precomputation. Then there are $|G|\cdot|\Sigma|\cdot r$ many such tableaux to compute and computing one takes $O(h^{2}\kappa)$ time. Therefore the precomputation takes $O(|G||\Sigma|\kappa h^{2}r)$ time but only $O(|G||\Sigma|\kappa hr)$ space, because only the final tableaux constructed in Algorithm 1 are stored. The $\mathsf{succ}$-mapping needs an additional $O(r^{2})$ space, but since $|G|r>r^{2}$ it is omitted in the upper bounds given. We then initialize the global state with $\mathsf{cTab}=t_{\varepsilon}$, $\mathsf{pos}=1$, and $\mathsf{cNode}=x$ for any $x\in V_{S}$. Now assume we want to traverse the $k$-th outgoing $\sigma^{\prime}$-edge of the current node towards the $l$-th neighbor, then we do the following:

Let $A=\mathsf{cTab}^{\mathsf{nt}}(\mathsf{pos})$ and $x=\mathsf{cNode}$. 2. 2.

If $\mathsf{tab}_{k}(A,x,\sigma^{\prime})\neq t_{\varepsilon}$:

$\mathsf{attach}(\mathsf{cTab},\mathsf{tab}_{k}(A,x,\sigma^{\prime}))$

Let $\mathsf{cTab}=\mathsf{tab}_{k}(A,x,\sigma^{\prime})$

Let $\mathsf{pos}=$ index of last row of $\mathsf{tab}_{k}(A,x,\sigma^{\prime})$ 3. 3.

Let $\mathsf{cNode}=\mathsf{succ}_{k,l}(A,x,\sigma^{\prime})$. 4. 4.

Let $\mathsf{internal}(\mathsf{cNode},\mathsf{cTab},\mathsf{pos})=(y,t,j)$ and let $\mathsf{cNode}=y$, $\mathsf{cTab}=t$, and $\mathsf{pos}=j$.

These steps take $O(1)$ time, except for the $\mathsf{attach}$ operation in Step 2, which takes $O(\kappa)$ time. Note Step $2$ is only done if the tableau is not the empty tableau $t_{\varepsilon}$. The reason for this is that $\mathsf{tab}_{k}(A,x,\sigma)=t_{\varepsilon}$ only if the path in the derivation tree does not change (i.e., the edge to be traversed is found in $\mathsf{rhs}(A)$). In this case only $\mathsf{cNode}$ changes. Compute $\mathsf{vertex}(\mathsf{cNode})=\mathsf{cTab}^{\mathsf{first}}(\mathsf{pos})+\mathsf{cTab}^{\mathsf{off}}+\mathsf{cNode}$ to find the corresponding node ID in $\mathsf{val}(G)$. ∎

The space needed can be given more precisely: using $\log(|G|)$-bit registers, four registers are necessary for every cell of a tableau: three for the $\mathsf{nxt}$ pointer (address of target tableau and two numbers for row and column) and one for $\mathsf{vtx}$.

5 Limits of the method

We finally want to give some indication as to why it is challenging to lift the unique-label restriction using the method presented here. Consider the grammar $G_{n}$ given in Figure 13. It generates a star-graph with one center vertex and $2^{n}$ $a$-neighbors. For the tableaux-method to work it would now be necessary to represent every node of the derivation tree with only $O(n)$ precomputed tableaux. However consider the derivation tree and tableaux given in Figure 14 for $n=3$. Clearly the tableaux modeling half of the derivation tree are all different. The other half (not shown in the figure) is also different but the differences are located only in the $\mathsf{vtx}$-values within the first rows, which is minor. That is the fifth tableaux (counting from the left) would be identical to the first with the only difference being that $\mathsf{vtx}$ in cell $(0,1)$ is $3$ instead of $2$. Moreover every leaf contains a vertex that is a neighbor of the $1$-node in the start graph. Thus if the goal is to support constant-time navigation to the $i$-th neighbor all of these tableaux need to be precomputed. Since there are $O(2^{n})$ many such tableaux this is not feasible.

We do note however that the grammar is a somewhat unnatural way of generating such a star-pattern. The more natural grammar in Figure 15 on the other hand has the property that every relevant node of the derivation tree is indeed modeled by almost the same tableau: the only difference between two tableaux here is that they use different $\mathsf{first}$-vectors. Using precomputed offsets it would likely be possible to adapt the $\mathsf{first}$-vectors at runtime to the concrete node. This way only a polynomial number of tableaux would be needed to traverse this grammar.

While these limitations are strong we do stress that any tree adheres to them and therefore the method can be used to traverse trees represented by SL tree grammars without the need of a conversion into a normal form. Furthermore if only unidirectional traversal is required the restrictions can be lifted slightly: assume the graph $\mathsf{val}(G)$ for a grammar $G$ has only rank 2 edges, and we are only interested in following them from source to target. Then the unique-label restriction only needs to apply to the source, not the target as we do not need to construct tableaux for the other direction.

6 Conclusions

We have presented a data structure which supports the traversal of hypergraphs given as straight-line hyperedge replacement (SL HR) graph grammars. A single traversal step along one hyperedge is carried out in constant time. Our method requires two restrictions:

each node can be the $k$-th incident node of at most one $\sigma$-labeled hyperedge for every edge label $\sigma$, and 2. 2.

the number of nodes incident with any nonterminal edge is bounded by a constant.

In the future we would like to investigate whether Restriction 1 can be removed or at least weakened. We would like to implement our data structure. It will be interesting to experimentally compare the traversal of trees represented via our data structure, against existing solutions for the constant delay traversal of grammar-compressed trees. A direct (more or less naive) implementation for grammar-compressed trees is investigated in a technical report [23]; it was rudimentally compared against a constant-time solution (using an implementation by Sadakane of succinct trees [1, 24] for solving the “next link problem”, cf. Section 4.1), giving slower times (on average) for the constant-time solution [7]. A comparison with the top-tree method [4] would also be very interesting, since this method allows for traversal with logarithmic delay without any additional structures.

Acknowledgements

This project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No 682588. The authors thank the anonymous reviewers for their many helpful comments.