Grammar-Based Graph Compression

TL;DR

This paper introduces a grammar-based graph compression method that recursively detects repeated substructures, resulting in smaller representations and enabling efficient query evaluation on compressed graphs.

Contribution

The paper proposes a novel grammar-based approach for graph compression that improves size reduction and query efficiency compared to existing methods.

Findings

Achieves smaller graph representations for many graph types.

Enables linear-time reachability queries on compressed graphs.

Allows regular path queries with quadratic time complexity.

Abstract

We present a new graph compressor that works by recursively detecting repeated substructures and representing them through grammar rules. We show that for a large number of graphs the compressor obtains smaller representations than other approaches. Specific queries such as reachability between two nodes or regular path queries can be evaluated in linear time (or quadratic times, respectively), over the grammar, thus allowing speed-ups proportional to the compression ratio.

Tables

Table 1. Table 1: Network graphs

Graph	$\left|V\right|$	$\left|E\right|$	$\left|\left[{\cong }_{\text{FP}}\right]\right|$
CA-AstroPh	18,772	396,160	14,742
CA-CondMat	23,133	186,936	17,135
CA-GrQc	5,242	28,980	3,394
Email-Enron	36,692	367,662	5,805
Email-EuAll	265,214	420,045	28,895
NotreDame	325,729	1,497,134	118,264
Wiki-Talk	2,394,385	5,021,410	566,846
Wiki-Vote	7,115	103,689	5,806

Table 2. Table 2: RDF graphs

Graph	$\left|V\right|$	$\left|E\right|$	$\left|\Sigma \right|$	$\left|\left[{\cong }_{\text{FP}}\right]\right|$
1 Specific properties en	609,014	819,764	71	236,235
2 Types ru	642,340	642,364	1	79
3 Types es	818,657	819,780	1	336
4 Types de with en	618,708	1,810,909	1	335
5 Identica	16,355	29,683	12	14,588
6 Jamendo	438,975	1,047,898	25	396,725

Table 3. Table 3: Version graphs

Graph	$\left|V\right|$	$\left|E\right|$	$\left|\Sigma \right|$	$\left|\left[{\cong }_{\text{FP}}\right]\right|$
Tic-Tac-Toe	5,634	10,016	3	9
Chess	76,272	113,039	12	74,592
DBLP60-70	24,246	23,677	1	2,739
DBLP60-90	658,197	954,521	1	207,305

Table 4. Table 4: Average results for different values of maxRank (compression in bpe).

	2	3	4	5	6	7	8
Network Graphs	11.74	11.59	11.44	11.94	12.51	13.67	12.92
RDF Graphs	5.17	5.40	4.85	4.92	5.60	6.12	6.25
Version Graphs	7.99	8.21	5.57	5.93	6.07	6.12	6.11

Table 5. Table 5: Results on RDF graphs (Size in KB)

RDF-Graph	1	2	3	4	5	6
gRePair	1,271	1	3	267	30	872
$k^2$-tree	2,731	590	938	1,119	52	988

Table 6. Table 6: Results on version graphs (compression in bpe)

	TTT	Chess	DBLP60-70	DBLP60-90
gRePair	0.12	9.06	9.54	13.39
$k^2$-tree	9.62	13.10	15.78	20.80
LM	-	-	16.44	19.32
HN	-	-	16.65	18.26

Table 7. Table 7: Results on triangle fractal- and grid-graphs for various values of n 𝑛 n , four orders, and 4 different values of maxRank.

		Triangle fractal				Grid
Order	MaxRank	$n=4$	$n=8$	$n=12$		$n=4$	$n=8$	$n=12$
FP	2	36.23%	4.61%	0.44%		98.26%	99.95%	100.00%
	4	46.38%	5.40%	0.50%		100.00%	95.95%	97.15%
	15	85.51%	23.59%	9.43%		100.00%	72.31%	46.38%
	$\infty$	85.51%	24.80%	6.23%		100.00%	70.00%	33.99%
FP0	2	36.23%	4.61%	0.44%		98.26%	99.95%	100.00%
	4	46.38%	16.54%	5.70%		100.00%	92.23%	93.37%
	15	46.38%	61.10%	8.99%		100.00%	99.93%	96.99%
	$\infty$	46.38%	61.10%	8.99%		100.00%	99.93%	96.99%
Nat	2	39.13%	4.79%	0.45%		98.26%	99.95%	100.00%
	4	100.00%	82.77%	80.69%		99.42%	95.88%	97.15%
	15	95.65%	28.72%	5.19%		94.77%	62.96%	75.48%
	$\infty$	95.65%	28.72%	4.51%		94.77%	13.13%	1.23%
BFS	2	60.87%	18.28%	7.49%		98.26%	99.95%	100.00%
	4	81.16%	54.22%	56.68%		100.00%	95.88%	97.15%
	15	81.16%	57.18%	72.33%		100.00%	47.81%	37.89%
	$\infty$	81.16%	52.13%	71.11%		100.00%	63.74%	(19.85%)

Equations

$$abcabcab$$

$$\begin{array}[]{lcl}S&\to&BBA\\ B&\to&Ac\\ A&\to&ab\end{array}$$

$$|g{|}_E=|\{e\in E_g\mid \mathsf{rank}(e)\le 2\}|+\sum _{e\in E_g,\mathsf{rank}(e)>2}\mathsf{rank}(e),$$

$$w=abcabcabc.$$

$$\begin{array}[]{lcl}S&\rightarrow&\mathit{BBB}\\ B&\rightarrow&\mathit{Ac}\\ A&\rightarrow&\mathit{ab}\end{array}$$

$$S$$

$$A(y_1,y_2)$$

$$B(y_1)$$

$$S$$

$$B(y_1)$$

$$f(f(f(a,a),a),f(f(f(a,a),a),a)),$$

$$\mathsf{con}(A)=|\mathsf{ref}(A)|\cdot (|\mathsf{rhs}(A)|-|\mathsf{handle}(A)|)-|\mathsf{rhs}(A)|,$$

$$U_i=\{u\in \mathsf{rhs}(A)\mid \exists v\in V_{g_i}:\text{ there is a path from }v\text{ to }u\text{ in }\mathsf{rhs}(A)\},$$

$$\mathsf{idx}[i]=\{j\mid \exists v\in V_{g_i}\text{ such that }v\text{ is at position }j\text{ within }{\mathsf{ext}}_{\mathsf{rhs}(A)}\}.$$

$$\sum _{i\in [k]}\mathsf{rank}(A_i)\le 2\mathsf{rank}(A)\text{ and }\sum _{i\in [k]}|g_i{|}_V\le 2|g{|}_V-1.$$

$$\mathsf{lab}(e_i)=\{\begin{array}{ll}{a}_0& \text{if }i\equiv 0(\mathrm{mod}5)\\ a_1& \text{if }i\equiv 1(\mathrm{mod}5)\\ a_2& \text{if }i\equiv 2(\mathrm{mod}5)\\ a_3& \text{if }i\equiv 3(\mathrm{mod}5)\\ a_4& \text{if }i\equiv 4(\mathrm{mod}5)\end{array},$$

$$|S|=2^{n+1}+2^n+2\cdot 2^{n-1}+4=2^{n+2}+4.$$

$$\frac{x}{|T_n|}=\frac{2^{n+1}+2^n+4}{2^{n+1}+2^{n+1}+2}\stackrel{n\to \infty }{⟶}\frac{3}{4}.$$

$$\begin{array}[]{ll}\delta(2)&\text{two edges}\\ 0\delta(2)&\text{edge is terminal ($0$), has two nodes}\\ 1\delta(1)1\delta(2)\delta(1)&\text{nodes 1 (external) and 2 (external), label 1}\\ 0\delta(2)&\text{next edge is terminal, has two nodes}\\ 1\delta(1)0\delta(3)\delta(1)&\text{nodes 1 (external) and 3 (internal), label 1}\end{array}$$

$$\begin{array}[]{llll}\delta_{\Sigma}&=\{&((q,q^{\prime}),\sigma,(p,p^{\prime}))\mid&q,p\in Q,q^{\prime},p^{\prime}\in Q^{\prime},\sigma\in\Sigma,\\ &&&(q,\sigma,p)\in\delta,\text{ and }(q^{\prime},\sigma,p^{\prime})\in\delta^{\prime}\},\text{ and}\\ \delta_{\varepsilon}&=\{&((q,q^{\prime}),\varepsilon,(p,p^{\prime}))\mid&q,p\in Q,q^{\prime},p^{\prime}\in Q^{\prime},\\ &&&(q,\varepsilon,p)\in\delta\text{ and }(q^{\prime},\varepsilon,p^{\prime})\in\delta^{\prime}\text{, or}\\ &&&(q,\varepsilon,p)\in\delta\text{ and }q^{\prime}=p^{\prime}\text{, or}\\ &&&q=p\text{ and }(q^{\prime},\varepsilon,p^{\prime})\in\delta^{\prime}\}.\\ \end{array}$$

$$E_{\otimes }=$$

$$\{e_{i,q,\epsilon ,p}\mid i\in V,(q,\epsilon ,p)\in \delta \}\cup$$

$$\{e_i\mid e_i\in E,\mathsf{lab}(e_i)\in N\}$$

$${\mathsf{att}}_{\otimes }(e_{i,q,\sigma ,p})$$

$${\mathsf{att}}_{\otimes }(e_{i,q,\epsilon ,p})$$

$${\mathsf{att}}_{\otimes }(e_i)$$

Full text

1 Introduction

Graph databases were investigated already some 30 years ago as described by Wood [54]. Today, with linked data on the web and social network data, there has been a resurgence of graph databases and graph processing systems. Compression is an important technique of dealing with large graph data: it saves storage space and data transfer time [18]. Grammar-based compression is a technique by which even query evaluation time can be saved. The idea is to compute a small context-free grammar generating a given object, e.g., a string, tree, or graph. Specific queries, e.g. queries performed by a finite-state automaton can be evaluated in linear time (and one pass) over such a grammar, thus providing speed-ups proportional to the compression ratio. Grammar-based compression has been known for strings and trees (see, e.g., [32, 34]). This paper investigates grammar-based graph compression. Our main contributions are:

1. (1)

we generalize to graphs the RePair compression scheme, 2. (2)

we experimentally evaluate an implementation of the compression scheme, and 3. (3)

we present new algorithms for query evaluation over compressed graphs.

Let us discuss these contributions in more detail. It is well-known that finding a smallest context-free grammar for a given string is NP-complete [9]. Various approximation algorithms have been considered, see [9]. A particularly effective and simple such algorithm is RePair by Larsson and Moffat [28]. The idea is to repeatedly replace a most-frequent digram in a string by a new nonterminal, and to introduce a corresponding rule for the nonterminal. A digram in a string consists of two consecutive symbols. For instance, the string

[TABLE]

has three occurrences of the digram $ab$, two occurrences of the digram $bc$, and two occurrences of the digram $ca$. Thus, RePair can replace the digram $ab$ by a new nonterminal, say $A$. The resulting string $AcAcA$ has two occurrences of the digram $Ac$ which may be replaced by the new nonterminal $B$ to obtain this grammar:

[TABLE]

Note that the size of the resulting grammar, i.e., the sum of lengths of the right-hand sides is $7$, i.e., is by one smaller than the length of the original string. RePair has been generalized to ranked, ordered trees by Lohrey, Mennicke, and Maneth [36]. For such trees, a digram consists of two nodes and an edge, i.e., a node and its $k$-th child for some $k$.

Consider the edge-labeled graph on the left of Figure 1a. Our idea is to define a digram as two edges which have least one node in common. The graph contains three occurrences of the digram consisting of an $a$- and a $b$-edge. The graph also contains three occurrences of the digram consisting of two $a$-edges (and the same for $b$), but these occurrences are overlapping so that there is at most one non-overlapping occurrence of that digram. If we replace each occurrence of the $a/b$-digram by a nonterminal edge labeled $A$, then we obtain the graph shown on the right of Figure 1a. The complete graph grammar for this graph is shown in Figure 1b. The size of the original graph (i.e., the sum of numbers of edges and nodes) is $11$, while the size of the grammar is $10$.

One of the major challenges in implementing RePair for graphs is that we are unable to determine a most-frequent (non-overlapping) digram in linear time. For strings and trees this is achieved by a trivial greedy left-to-right and bottom-up counting procedure, respectively. Let us consider an example to see why in a graph a greedy counting procedure does not find a maximal set of non-overlapping occurrences of a digram. We follow a specific node order and greedily count occurrences of digrams with the current node as center node. If we start with the node numbered “1” in Figure 2a, then we count exactly two non-overlapping occurrences of a digram (note that the gray shaded areas are occurrences of a different digram). If however, we follow the order of nodes shown in Figure 2b, then we find four occurrences of the same digram. The most efficient way we are aware of for finding a most-frequent (non-overlapping) digram in a graph has quadric time complexity. This is prohibitively expensive for large graphs. We therefore resort to a greedy counting principle which can be performed in linear time. We experiment with different node orders. Interestingly, a node order based on the “similarity” of nodes inspired by the numbering from the Weisfeiler-Lehman isomorphism test [53] achieves the best results in our experiments.

We run experiments with a prototype implementation of our RePair for graphs compression algorithm. Note that typically the algorithm ends up with a large graph that does not contain repeated digrams. Thus, we need an efficient way to represent this rest graph. We use the $k^{2}$-trees of Brisaboa, Ladra, and Navarro [5]. We compare our compressor against $k^{2}$-trees, the list-merge compressor (LM) of Grabowski and Bieniecki [24], and the compressor of Hernández and Navarro [27]. The latter first applies a generalization of the dense substructure removal (DSR) of Buehrer and Chellapilla [6] and then uses $k^{2}$-trees. We find that over network graphs (which have no edge labels), the combination of our new RePair algorithm with DSR gives the best results for all graphs but two (where LM obtains slightly better compression). On RDF graphs (which contain edge labels) we compare our compressor with $k^{2}$-trees. Here our method consistently obtains better compression, sometimes by a factor of several hundreds.

We finally investigate query evaluation over grammar-compressed graphs. For strings and trees one basic technique is to run a finite-state automaton in one pass over the grammar. Unfortunately, for graphs there is no well accepted notion of a finite-state automaton. Instead, counting monadic second-order logic (CMSO) is considered as the graph counterpart to regular languages. It follows from well-known results that evaluating a fixed CMSO formula over a grammar-compressed graph can be carried out in (data complexity) time $O(\eta|G|)$ where $\eta$ is an upper bound on the time needed to evaluate the formula over a right-hand side of the grammar [11]. Since this may be too expensive for large graphs, we investigate new algorithms for particular queries. Given a graph grammar $G$, (a) reachability queries (for nodes $s,t$ determine if there is a path from $s$ to $t$) can be evaluated in time $O(|G|)$, and (b) regular path queries (i.e., determine if there exists two nodes with a labeled path between them matching a regular expression $\alpha$) can be evaluated in time $O(|G||\alpha|)$.

This paper is based on a preliminary paper that was presented at ICDE 2016 (see[41]). We have added several new results and new material with respect to the ICDE 2016 paper. In particular have we greatly extended the Related Work section. Section 4.4 on tree- and string-graphs is entirely new; the main result of that section (Theorem 6 and Corollary 7) essentially shows that SL-HR grammars do not allow stronger tree or string compression as do the existing well-known straight-line tree and string grammars. Section 4.5.2 is entirely new; it shows that the maximal rank parameter can heavily influence the compression behavior or our compressor. Section 4.7 is entirely new; it discusses the choice of our grammar formalism and compares it to other formalisms such as node replacement graph grammars. The experimental section has been extended by new experiments over synthetic graphs, which allow to show the influence of the individual parameters of the compressor. The section on Query Evaluation has been largely extended; for instance, an algorithm to traverse a grammar-represented graph and a new section on regular path queries has been added.

2 Related Work

Our grammar formalism is known as context-free hyperedge replacement (HR) grammars, see [17, 12]. An approximation algorithm for finding a small HR grammar that generates a given graph is considered already by Peshkin [48]. It is based on the SEQUITUR compression scheme [46]. However, experiments are only presented for rather small protein graphs, and we have not been able to obtain their implementation. As far as we know, no other compressor for straight-line graph grammars has been considered. Claude and Navarro [10] apply string RePair on the adjacency list of a graph. This works well, but is outperformed by newer compression schemes such as $k^{2}$-trees [5]. More database oriented work is found for semi-structured data. For example the XMill-compressor [31] groups XML-data such that a subsequent use of general-purpose compression (e.g. gzip) is more effective. Schema information can improve its effectiveness, but is not required. Deriving schema information from existing data can be seen as a form of lossy compression. DataGuides [23] are a way of doing just that for XML data. As XML documents can be represented as trees, methods to compress trees are applicable. Grammar-based tree compression can be seen as a precursor to the work presented here. One of the first such algorithms was BPLEX [7]. The results of BPLEX were later improved by applying the RePair compression scheme to trees [36], which is what we are proposing to do for graphs.

2.1 Succinct Graph Representations

Several compression approaches have been developed particularly for web graphs. In a web graph, nodes represent pages (i.e., URLs) and edges represent links from one page to another. Web graphs have two properties which are useful for compression:

Locality:

most links lead to pages within the same host (i.e., the URLs have the same prefix) and

Similarity:

pages on the same host often share the same links.

Due to these properties, ordering the nodes lexicographically by their URL provides an order in which similar nodes are close to each other. The WebGraph framework [4] by Boldi and Vigna is originally based on this order, but was later improved with a different order [3]. It represents the adjacency list of a graph using several layers of encodings, while retaining the ability to answer out-neighborhood queries. An out-neighborhood (in-neighborhood) query applied to a node $u$ retrieves all nodes $v$ such that there is an edge from $u$ to $v$ (from $v$ to $u$). As not every graph is a web graph, a lexicographical order of the node-names is not always possible or useful. Apostolico and Drovandi therefore propose to use a BFS-order [2] combined with another encoding. A different approach is proposed by Grabowski and Bieniecki [24], where contiguous blocks of the adjacency list are merged into a single ordered list, and a list of flags which are used to recover the original lists. They then encode the ordered list and use the deflate-compressor to compress both lists. To our knowledge, their method is the current state-of-the-art in compression/query trade-off, when only out-neighborhood queries are considered.

The methods above have in common that they encode the adjacency list of a graph and natively only support out-neighborhood queries. The $k^{2}$-trees of Brisaboa et al. [5] on the other hand compress the adjacency matrix of the graph. They do this by recursively partitioning it into $k^{2}$ many squares. If one of these includes only 0-values, then it is represented by a 0-leaf in the tree, and otherwise the square is partitioned further. This Quadtree-like representation is well known (see, e.g., [55]), but their succinct binary encoding is a clever new approach. The method provides access to both, in- and out-neighborhood queries, and can be applied to any binary relation. We use $k^{2}$-trees to represent the start graph of our grammars. The $k^{2}$-tree-method was combined by Hernández and Navarro [27] with dense substructure removal, originally proposed by Buehrer and Chellapilla [6]. A dense substructure is defined by two sets of nodes $U,S$ such that they induce a complete bipartite graph. Note that $U$ and $S$ need not be disjoint. The edges in these bicliques are replaced by a single “virtual node”. To our knowledge, the method of [27] is the current state-of-the-art in compression/query trade-off, when in- and out-neighborhood queries are considered.

2.2 RDF Graph Compression

The Resource Description Framework (RDF) is a fairly recent specification, first standardized by the w3c in February 2004. The current version is RDF1.1111https://www.w3.org/TR/2014/REC-rdf11-concepts-20140225/ from February 2014. It is used to represent linked data and semantic information. Its relationship to graphs is similar to XML’s relationship to trees, in that graphs are a natural representation of the structure defined by RDF. Roughly speaking, RDF data is represented as a set of triples $(s,p,o)$, connecting a subject $s$ with an object $o$ by a predicate $p$. Notably, the domains for these can overlap to some degree (for example, values used as predicates in some triples may be subjects in others). Such a set of triples can be represented by having nodes for the subjects and objects, and edges for the predicates. Thus $(s,p,o)$ becomes an edge from $s$ to $o$ labeled $p$. Note that it is not necessary to model overlapping domains as edges pointing to other edges. Instead, there may be a node label that also appears as an edge label. As RDF graphs encode semantic information, the concrete values for subjects, predicates, and objects can be long strings (for example URIs). It is a common practice (see e.g. [19, 45, 1]) to map the possible values to integers using a dictionary and to represent the graph using triples of integers. This also leads to different approaches regarding RDF graph compression: one is to compress the dictionary further (see, e.g., [45, 52]), another to compress the underlying graph structure.

Of the methods mentioned in the previous section, only the $k^{2}$-tree has been applied to RDF graph compression [1]. This is done by encoding a separate adjacency matrix for every predicate (i.e., edge label) in the graph. The aforementioned splitting into dictionary and triples was first proposed by Fernández et al. [20] as a datastructure called HDT (Header-Dictionary-Triples). Together with an encoding of the triples grouping them by subject as an adjacency list, this yields an in-memory representation of RDF data. They also investigate compressing this data structure using conventional general-purpose compression methods (gzip, bzip2, and ppmdi), beating these universal compressors used on the plain original file. Another approach of Swacha and Grabowski [49] combines techniques to compress graph and dictionary achieving a succinct representation of the RDF graph, which is subsequently compressed by general purpose compressors.

2.3 Queries with Compressed Input

Often compressed input induces an exponential blow-up in complexity when deciding queries on the represented data. Such “upgrading-theorems” have been shown for example for the representation of graphs as boolean circuits, which can be exponentially smaller than an explicit representation, but in turn make queries exponentially harder to answer (see e.g. [21, 47]). Fortunately, upgrading-theorems do not hold for grammar-compressed graphs as already shown in [29]. Indeed, it is possible to obtain a speed-up proportional to the compression ratio for certain queries. Lengauer and Wanke [30] show that connectivity of graphs specified using a hierarchical graph definition (which is essentially the same as the hyperedge replacement mechanism we use in this paper) can be decided in linear time with respect to the size of the compressed representation. They also show this for biconnectivity and (undirected) reachability. For strong connectivity however, they only get a quadratic upper bound. It should be noted that there is still an increase in complexity here, but a smaller one. Lengauer and Wagner [29] study several problems and their complexity on explicit versus hierarchical representations. They show, for example, that reachability is complete for ${\mathsf{P}}$ on hierarchical graphs, but the problem is ${\mathsf{NL}}$-complete for explicit representations. The latter class is widely believed to be a proper subset of the former, but both classes only include problems which can be solved in polynomial time, so there is no exponential blow-up in computation time. As the hierarchical representation can be exponentially smaller than the represented graph, this makes a speed-up possible. This smaller increase in complexity is also stated by Marathe et al. [44, 42, 43], who show that some ${\mathsf{NP}}$-complete problems on graphs (e.g., 3-colorization, Max Cut, and Vertex Cover) become ${\mathsf{PSPACE}}$-hard on hierarchically defined graphs, which again does not imply an exponential blow-up in computation time (assuming widely-held assumptions in complexity theory). They also present polynomial approximation algorithms for some of these problems with hierarchical input. Note that we cannot conclude that hierarchical versions of classical problems always lead to a speed-up: in the same paper they show that the ${\mathsf{P}}$-complete threshold network flow problem becomes ${\mathsf{PSPACE}}$-complete for hierarchical input graphs.

3 Preliminaries

For $n\geq 0$ we denote by $[n]$ the set $\{1,\ldots,n\}$. A ranked alphabet consists of an alphabet $\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 fixed, and of the form $[\sigma]$ for some integer $\sigma\in\mathbb{N}$.

As we do some comparisons to grammar-based string and tree compression, let us recall some definitions. We denote the empty string by $\varepsilon$, and for two strings $w,v$ the concatenation of $w$ and $v$ by $w\cdot v$, or $wv$ if that is unambiguous. Let $\Delta$ be an alphabet (that is, a finite set of symbols). The size of a string $w=a_{1}a_{2}\cdots a_{k}$ ($a_{i}\in\Delta$ for $i\in[k]$) is defined as $|w|=k$ with $|\varepsilon|=0$, and we write $a_{i}\in w$ to express that $a_{i}$ is part of the string $w$. We recursively define trees over a ranked alphabet $\Sigma$ as the smallest set $T$, such that for $k\geq 0$, if $t_{1},\ldots,t_{k}\in T$, then $\sigma(t_{1},\ldots,t_{k})\in T$, provided that $\sigma\in\Sigma$ and $\mathsf{rank}(\sigma)=k$. The nodes of a tree $t$ can be addressed by their Dewey addresses $D(t)$. For a tree $t=\sigma(t_{1},\ldots,t_{k})$, $D(t)$ is recursively defined as $D(t)=\{\varepsilon\}\cup\bigcup_{i\in[k]}i\cdot D(t_{i})$. Thus $\varepsilon$ addresses the root node, and $u\cdot i$ the $i$-th child of $u$. For $u\in D(t)$ we denote by $t[u]\in\Sigma$ the symbol at $u$. The size of $t$ is $|t|=|D(t)|-1$, i.e., the number of edges in $t$.

A hypergraph over $\Sigma$ (or simply graph) is a tuple $g=(V,E,\mathsf{att},\mathsf{lab},\mathsf{ext})$ where $V=\{1,\ldots,n\}$, $n\geq 1$ is the set of nodes, $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 nodes. 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 edge $e$ in $E$. The latter requirement (and the attachment mapping mapping to $V^{+}$) mean that we do not allow edges that are not attached to any nodes. We add the following two restrictions on hypergraphs:

1. (C1)

for all edges $e\in E:\mathsf{att}(e)$ contains no node twice, and 2. (C2)

$\mathsf{ext}$ contains no node twice.

An edge is simple, if its rank equals two. A hypergraph $g$ is simple, if all its edges are simple, and for any distinct edges $e_{1},e_{2}$ of $g$ it holds that $\mathsf{att}(e_{1})\neq\mathsf{att}(e_{2})$ or $\mathsf{lab}(e_{1})\neq\mathsf{lab}(e_{2})$, i.e., $g$ has no “multi-edges”. For a hypergraph $g=(V,E,\mathsf{att},\mathsf{lab},\mathsf{ext})$ we use $V_{g},E_{g},\mathsf{att}_{g},\mathsf{lab}_{g}$, and $\mathsf{ext}_{g}$ to refer to its components. We may omit the subscript if the hypergraph is clear from context. The rank of a hypergraph $g$ is defined as $\mathsf{rank}(g)=|\mathsf{ext}_{g}|$. Nodes that are not external are called internal. We define the node size of $g$ as $|g|_{V}=|V|$, the edge size as

[TABLE]

and the size as $|g|=|g|_{V}+|g|_{E}$. We denote the set of all hypergraphs over $\Sigma$ by $\mathsf{HGR}(\Sigma)$. Note that our size definition differs slightly from the one given in [30], because they are encoding hyperedges using bipartite graphs. Thus, an edge of rank $n$ in our model has size $n$ (or 1 if $n\leq 2$), whereas they would calculate a size of $n$ edges and one node. This makes our sizes slightly smaller. For two nodes $s,t\in V$ we say that there is a path $p$ from $s$ to $t$, if there exists a sequence of edges $p=(e_{1},\ldots,e_{n})\in E^{n}$ for some $n\in\mathbb{N}$, such that $\mathsf{att}(e_{1})=s\alpha$ ($\alpha\in V^{*}$), $\mathsf{att}(e_{n})=v\beta$ with $v\in V,\beta\in V^{+}$ and $t\in\beta$, and for every $i\in[n-1]$ if $\mathsf{att}(e_{i})=uv_{1}\cdots v_{k}$ then there exists a $j\in[k]$ such that $\mathsf{att}(e_{i+1})=v_{j}\alpha$ for some $\alpha\in V^{*}$. For an edge $e$ let $\mathsf{head}(e)$ be the first node $e$ is attached to. For a path $p=(e_{1},\ldots,e_{n})$ we refer to the nodes $(\mathsf{head}(e_{2}),\ldots,\mathsf{head}(e_{n}))$ as the nodes on the path $p$. We call $p$ internal, if all the nodes on $p$ are internal.

An example of a hypergraph can be seen in Figure 3. Formally, the pictured graph has $V=\{1,2,3\}$, $E=\{e_{1},e_{2},e_{3}\}$, $\mathsf{att}=\{e_{1}\mapsto 1\cdot 2,e_{2}\mapsto 2\cdot 3,e_{3}\mapsto 2\cdot 1\cdot 3\}$, $\mathsf{lab}=\{e_{1}\mapsto a,e_{2}\mapsto b,e_{3}\mapsto A\}$, and $\mathsf{ext}=3\cdot 1$. Note that external nodes are filled black and have indices below them indicating their position within $\mathsf{ext}$. Similarly, the hyperedge of rank $>2$ has indices indicating the order of the attached nodes (simple edges are drawn directed, from their first to second attachment node). In the following we sometimes omit either of these indices. In these cases, we either use colors to indicate this order, or the specific order is irrelevant for the example.

Definition 1**.**

A hyperedge replacement grammar (HR grammar) over $\Sigma$ is a tuple $G=(N,P,S)$, where $N\subseteq\mathbb{N}$ is a ranked alphabet of nonterminals with $N\cap\Sigma=\emptyset$, $P\subset N\times\mathsf{HGR}(\Sigma\cup N)$ is the set of rules 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.

The size of $G$ is defined as $|G|=\sum_{(A,g)\in P}|g|$, and similarly the edge and node sizes $|G|_{E}=\sum_{(A,g)\in P}|g|_{E}$ and $|G|_{V}=\sum_{(A,g)\in P}|g|_{V}$. The rank of an HR grammar $G$ is defined by $\mathsf{rank}(G)=\max\{\mathsf{rank}(A)\mid A\in N\}$. 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 relation for the grammar $G=(N,P,S)$, we first introduce some notation. Let $g$ be a hypergraph, $\rho:V_{g}\rightarrow\mathbb{N}$ a bijective function, and $\rho^{*}:V_{g}^{*}\rightarrow\mathbb{N}^{*}$ the natural extension of $\rho$ to strings. We call $\rho$ a node 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 nodes that exist in both $g$ and $h$, 2. 2.

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

uses the external nodes of $g$ only.

Now, let $g,h$ be hypergraphs and $e\in E_{g}$ such that $\mathsf{rank}(e)=\mathsf{rank}(h)$. Let $\rho$ be a node renaming on $h$ such that $\mathsf{ext}_{h[\rho]}=\mathsf{att}_{g}(e)$, and $\rho(v)\notin V_{g}$ for every internal node $v$ of $h$. The replacement of $e$ by $h$ in $g$ is defined as $g[e/h]=g[-e]\cup h[\rho]$.

For a grammar $G=(N,P,S)$ we define its derivation relation $\Rightarrow_{G}\subseteq\mathsf{HGR}(\Sigma\cup N)\times\mathsf{HGR}(\Sigma\cup N)$ as follows. For $g,h\in\mathsf{HGR}(\Sigma\cup N)$, $g\Rightarrow_{G}h$ if and only if there is a nonterminal edge $e$ in $g$ such that $h=g[e/\mathsf{rhs}(\mathsf{lab}(e))]$. For $n\geq 1$ we write $g\Rightarrow^{n}_{G}h$, if there is a sequence $g\Rightarrow_{G}g_{1}\Rightarrow_{G}\cdots\Rightarrow_{G}g_{n-1}\Rightarrow_{G}h$ of $n$ derivation steps to derive $h$ from $g$, and extend this to $g\Rightarrow^{*}h$, if $g\Rightarrow^{n}h$ for some $n\in\mathbb{N}$. The language of a grammar $G$ is defined as $L(G)=\{g\in\mathsf{HGR}(\Sigma)\mid S\Rightarrow^{*}g\}$. We omit the subscript $G$ where the grammar is clear from context. For an example of a derivation, see Figure 4, which shows the full derivation of the grammar given in Figure 1b. Note that the nodes in the start graph initially have IDs $1$ and $2$, whereas the nodes that originate from the internal node of the right-hand side of $A$ get variables $x,y$, and $z$. Any pairwise different values for these variables that are different from $1$ and $2$ yield a correct derivation of this grammar.

Definition 2**.**

An HR grammar $G$ is called straight-line (SL-HR grammar) if

the relation $\leq_{\mathsf{{NT}}}=\{(A_{1},A_{2})\mid\exists g:(A_{1},g)\in P_{G},\exists e\in E_{g}:\mathsf{lab}_{g}(e)=A_{2}\}$ is acyclic, 2. 2.

for every $A\in N$ there exists exactly one rule $p\in P_{G}$ with $\mathsf{lhs}(p)=A$, and 3. 3.

$G$ has no useless (unreachable) rules, i.e., if $S_{G}\Rightarrow g_{1}\Rightarrow\cdots\Rightarrow g_{n}\in\mathsf{HGR}(\Sigma)$ and $A\in N_{G}$, then $\exists i\exists e\in V_{g_{i}}:\mathsf{lab}_{g_{i}}(e)=A$.

Note that $L(G)\neq\emptyset$ and $L(G)$ contains (due to the element of choice in the node renaming, possibly infinitely many) only 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 startgraph (i.e., $S$ is assumed to be implicitly in $N$ and $\mathsf{rhs}(S)=S$). The height of an SL-HR grammar $0pt(G)$ is the height of $\leq_{\mathsf{{NT}}}$. Note that in terms of the expressive power of HR grammars for defining graph languages, the conditions (C1) and (C2) do not have an effect, see [25, Chapter 1, Theorem 4.6]. In terms of compression power however, condition (C1) is harmless, but (C2) is not. See Section 4.7 for more details. In the following we often say grammar instead of SL-HR grammar.

3.1 Creating Graphs with Unique Node IDs

Let $G$ be an SL-HR grammar. Instead of considering all the (possibly infinitely many) isomorphic graphs in the set $L(G)$, we would like to fix one particular graph $g$ of $L(G)$. First of all, we fix a particular node renaming during a derivation step. Let $g$ be a graph with a nonterminal edge $e$ labeled $A$, and let $h=\mathsf{rhs}(A)$. Further, let $|V_{g}|=n$ and let $v_{1},\ldots,v_{m}$ be the internal nodes of $h$ such that $v_{i}<v_{j}$ for $i<j$. In the definition of $g[e/h]=g[-e]\cup h^{\rho}$, we now require $\rho(v_{i})=n+i$ for $i\in[m]$.

This alone is not enough. We also need to define in which order the nonterminal edges are derived, to make sure the full derivation ends up with a unique graph. To do so, let first $g$ be a graph, and $E^{\text{NT}}_{g}=\{e\in E_{g}\mid e$ is nonterminal$\}$ be the set of nonterminal edges in $g$. We define the sibling-tuple $\mathsf{sib}(E^{\text{NT}}_{g})$ of $E^{\text{NT}}_{g}$ as the tuple $(e_{1},\ldots,e_{k})$ such that $\bigcup_{i\in[k]}e_{i}=E^{\text{NT}}_{g}$, and if $i<j$ (for $i,j\in[k]$, i.e., $e_{i}$ comes before $e_{j}$ in the tuple), then

• •

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

• •

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

Note that the order for edges with $\mathsf{att}_{g}(e_{i})=\mathsf{att}_{g}(e_{j})$ and $\mathsf{lab}_{g}(e_{i})=\mathsf{lab}_{g}(e_{j})$ is arbitrary, as it does not matter. Intuitively, the sibling-tuple is an ordered sequence of siblings within the derivation tree of $G$. Using this order we define the derivation-tree $\mathsf{dt}(G)$ for an SL-HR grammar $G=(N,P,S)$ recursively in the following way: let $e$ be a nonterminal edge labeled $A$, let $g=\mathsf{rhs}(A)$, and let $\mathsf{sib}(E^{\text{NT}}_{g})=(e_{1},\ldots,e_{m})$ for $m\geq 0$. Then $\mathsf{dt}(e)=e(\mathsf{dt}(e_{1}),\ldots,\mathsf{dt}(e_{m}))$. To define the root of the tree, let $\mathsf{sib}(E^{\text{NT}}_{S})=(e_{1},\ldots,e_{m})$, and $\mathsf{dt}(G)=S(\mathsf{dt}(e_{1}),\ldots,\mathsf{dt}(e_{m}))$. Figure 5 shows an example of a derivation tree. The order in which the nonterminal edges of $G$ are derived is now given by a pre-order traversal (i.e., a depth-first traversal, which always visits the leftmost unvisited node next) of $\mathsf{dt}(G)$. This yields a unique hypergraph out of the many isomorphic options in $L(G)$. We denote this hypergraph by $\mathsf{val}(G)$. We denote the hypergraph derived by a single edge $e$ in this way by $\mathsf{val}(e)$. Finally we denote by $\mathsf{val}(A)$ the hypergraph derived from a graph with $\mathsf{rank}(A)$ many nodes attached to a single $A$-edge.

For an example consider first again the derivation shown in Figure 4. The only allowed choice of node-IDs for $\mathsf{val}(G)$ here would be $x=3$, $y=4$, and $z=5$. Furthermore, Figure 6 shows the graph resulting from the derivation of the grammar given in Figure 5. Note how in both cases the order in which the $A$-edges between nodes $1$ and $2$ are derived does not matter: if we were to switch the node-IDs created by them ($4$ and $5$ in Figure 6) we would still have the same graph, not just an isomorphic one.

3.2 String- and Tree-Graphs

Strings and trees can be conveniently encoded as hypergraphs. As the latter structure is more complex, this affects the size. We make use of these encodings, when discussing the relation of graph compression to previously proposed string- and tree-compression in Section 4.4. Let $w=a_{1}\cdots a_{n}$ be a string. We define the hypergraph $\mathsf{s\text{-}graph}(w)$ representing the string $w$ as $(\{0,1,\ldots,n\},E_{w},\mathsf{att}_{w},\mathsf{lab}_{w},\mathsf{ext}_{w})$, where $E_{w}=\{e_{1},\ldots,e_{n}\}$. For an edge $e_{i}\in E_{w}$ we let $\mathsf{att}_{w}(e_{i})=i-1\cdot i$ and $\mathsf{lab}(e_{i})=w_{i}$. Finally the external nodes are $\mathsf{ext}_{w}=0\cdot n$. The size of $\mathsf{s\text{-}graph}(w)$ is $2n+1=2|w|+1$. Note that the external nodes indicate beginning and end of the string. Figure 7a shows $\mathsf{s\text{-}graph}(w)$ for $w=abca$.

The encoding for trees is a little less straight-forward, because the node labels are moved into the edges, and the children of a node in a tree are ordered. We convert a node with $k$ children into a hyperedge of rank $k+1$ (as it is connected to the parent as well). The order of the hyperedge retains the order of the children and the parent is always located at the first node attached to a hyperedge. This is a well-known encoding, see e.g., [15]. Let $t$ be a tree, and let $<_{t}$ be the lexicographical order on $D(t)$. For an address $i\in D(t)$ we denote by $\mathsf{pos}(i)$ the position of $i$ within the order $<_{t}$, such that $\mathsf{pos}(\varepsilon)=0$. We define the hypergraph $\mathsf{t\text{-}graph}(t)$ representing the tree $t$ as $(\{0,1,\ldots,|D(t)|\},\{e_{i}\mid i\in D(t)\},\mathsf{att},\mathsf{lab},0)$, where for $i\in D(t)$ and $k=\mathsf{rank}(t[i])$,

• •

$\mathsf{att}(e_{i})=(\mathsf{pos}(i))\cdot(\mathsf{pos}(i)+1)\cdots(\mathsf{pos}(i)+k)$, and

• •

$\mathsf{lab}(e_{i})=t[i]$.

The size of $\mathsf{t\text{-}graph}(t)$ is between $2|t|+2$ (for a monadic tree $t$) and $3|t|+2$ (for a tree where every inner node has rank greater than $1$). Figure 7b shows $\mathsf{t\text{-}graph}(t)$ for $t=f(a,g(a,b))$.

4 GraphRePair

We present our generalization to graphs of the RePair compression scheme.

4.1 RePair Compression Scheme for Strings and Trees

Let us first explain the classical RePair compressor for strings and trees. The RePair compression scheme is an approximation algorithm for a smallest context-free grammar for a given string. The smallest grammar problem is the problem of deciding, given a string $w$ and a number $k\in\mathbb{N}$, whether there exists a straight-line grammar $G$ of size at most $k$ generating $w$. It was shown by Charikar et al. [9] that the smallest grammar problem is ${\mathsf{NP}}$-complete. Hence, already for string-graphs it follows that finding a smallest grammar is ${\mathsf{NP}}$-hard. In a string, a digram consists of two consecutive symbols. The idea of Larsson and Moffat’s RePair Compression scheme [28] is to repeatedly replace all (non-overlapping) occurrences of a most frequent digram by a new nonterminal. The process ends when no repeating digrams occur. Consider as an example the string

[TABLE]

It contains occurrences of the digrams ab (3 times), bc (3 times), and ca (2 times). If ab is replaced by $A$ then we obtain AcAcAc. If now Ac is replaced by $B$, then we obtain this grammar

[TABLE]

Note that the original string $w$ has size $|w|=9$, whereas the grammar has size $7$ (the size of a grammar is the sum of the sizes of its right-hand sides). Note that overlapping occurrences only exist for digrams of the form $aa$.

To compute in linear time such a grammar from a given string requires a set of carefully designed data structures. The input string is represented as a doubly linked list. Additionally a list of active digrams (digrams that occur at least twice) is maintained. Every entry in the list of active digrams points to an entry in a priority queue $Q$ of length $\sqrt{n}$ (with $n$ being the length of the input string) containing doubly linked lists. The list with priority $i$ in $Q$ contains every digram that occurs $i$ times, the last list contains every digram occurring $\sqrt{n}$ or more times. The list items also contain pointers to the first occurrence of the respective digram. This queue is used to find the most frequent digram in constant time. Larsson and Moffat [28] prove that $\sqrt{n}$-length guarantees a linear runtime for the complete algorithm. Basically, in a string of length $n$ the most occurrences a digram can have is $n/2$ and in that case no other digram can occur as often in the string. There may, in general, be more than one digram occurring more than $\sqrt{n}$ times, but the last list can not have more than $\sqrt{n}$ entries, and the frequency of the most frequent digram is monotonely decreasing. This overall leads to a linear running time. All these data structures are updated whenever an occurrence is removed. Consider removing one occurrence of ab in the example above: when doing so, one occurrence of bc and possibly ac need to be removed from the list. On the other hand, new occurrences of Ac and possibly cA are created.

An even smaller grammar than the one above can be obtained through pruning, which removes nonterminals that are referenced only once, i.e., pruning would remove the nonterminal $A$ in the grammar above, so that the $B$-rule becomes $B\rightarrow\mathit{abc}$. This reduces the size of the grammar from $7$ to $6$. Note that pruning can never increase the size of the grammar (but may not decrease it).

RePair was generalized to trees by Lohrey et al. [36]. Here a digram consists of two nodes, and the $i$-edge between them, with $i$ meaning that the second node is the $i$-th child of the first node, denoted by $(a,i,b)$. Note that overlapping occurrences can only happen for digrams of the form $(a,i,a)$. A digram $(a,i,b)$ has, in a binary tree, at most three “dangling edges”. Dangling edges in context-free tree grammars are represented by parameters of the form $y_{1},\ldots,y_{k}$. The number $k$ is the rank of the rule (digram). E.g. the $A$-rule in Figure 9 represents a digram of rank 1, while the $B$-rule represents a digram of rank 3. The rank of a grammar is defined as the maximal rank of a rule occurring in the grammar. Parameters have a similar role to external nodes in HR grammars, as they indicate how the right-hand side is connected with the tree during a derivation. Similarly to string grammars, the size of a tree grammar is the sum of sizes of its right-hand sides. Note that neither of the two replacements shown in Figure 9 make the resulting grammar smaller and would thus not be considered contributing: the digram represented by the $B$-rule only occurs once, therefore replacing it makes the grammar larger. Replacing the digram represented by the $A$-rule reduces the size of the tree by $2$, but the right-hand side of the rule has size two as well, thus leading to a grammar that has the same size as the original graph. Were the digram to occur once more however, the replacement would become contributing. The rank of a grammar also has an impact on further algorithms run on it, see e.g. [35, 37]. Keeping the rank small is thus desirable. Therefore, TreeRePair has a user-defined “maxRank” parameter.

4.2 RePair on Graphs

The first step in generalizing RePair to graphs, is defining the notion of a digram in a graph. For simple graphs two options come up naturally: two neighboring nodes and the edge between them, or two edges with a common node. The first option is not viable, as it does not allow to compress some very basic graphs: consider a cycle $C_{n}$ consisting of $n$ consecutive edges (and $n$ nodes). Replacing a digram of the first kind does not remove nodes nor edges, and only relabels edges by a nonterminal. Thus no compression is achieved. We therefore use the latter option.

Definition 3**.**

A digram over $\Sigma$ is a hypergraph $d\in\mathsf{HGR}(\Sigma)$, with $E_{d}=\{e_{1},e_{2}\}$ such that

for all $v\in V_{d}$, $v\in\mathsf{att}_{d}(e_{1})$ or $v\in\mathsf{att}_{d}(e_{2})$, 2. 2.

there exists a $v\in V_{d}$ such that $v\in\mathsf{att}_{d}(e_{1})$ and $v\in\mathsf{att}_{d}(e_{2})$, and 3. 3.

$\mathsf{ext}_{d}\neq\varepsilon$.

Every possible digram over undirected, unlabeled edges is shown in Figure 8. Note that we grouped some of the digrams. This is because, one can represent one by the other by using a different order in the $\mathsf{att}$-relation of the nonterminal edge. Another example for digrams are the right-hand sides of the two $A$-rules in Figure 10. Note that both grammars in the figure generate the graph on the left. However, they differ in size: the grammar in the middle has size 12, while the grammar on the right has size 9 (recall that simple edges have size 1).

As mentioned before, RePair replaces a digram that has the largest number of non-overlapping occurrences.

Definition 4**.**

Let $g,d\in\mathsf{HGR}(\Sigma)$ such that $d$ is a digram. Let $e_{1}^{d},e_{2}^{d}$ be the two edges of $d$. Let $o=\{e_{1},e_{2}\}\subseteq E_{g}$ and let $V_{o}$ be the set of nodes incident with edges in $o$. Then $o$ is an occurrence of $d$ in $g$, if there is a bijection $\psi:V_{o}\rightarrow V_{d}$ such that for $i\in\{1,2\}$ and $v\in V_{o}$

$\psi(v)\in\mathsf{att}_{d}(e_{i}^{d})$ if and only if $v\in\mathsf{att}_{g}(e_{i})$, 2. 2.

$\mathsf{lab}_{d}(e_{i}^{d})=\mathsf{lab}_{g}(e_{i})$, and 3. 3.

$\psi(v)\in\mathsf{ext}_{d}$ if and only if $v\in\mathsf{att}_{g}(e)$ for some $e\in E_{g}\setminus\{o\}$.

The first two conditions of this definition ensure that the two edges of an occurrence induce a graph isomorphic to $d$. The third condition requires that every external node of $d$ is mapped to a node in $g$ that is incident with at least one other edge. Thus, the edges marked in the graph on the left of Figure 10 constitute an occurrence of the digram $(b)$ of Figure 8, which is the same as the one of the $A$-rule of the right grammar, but not an occurrence of the digram of the $A$-rule in the middle grammar (digram $(a)$ of Figure 8). We call the nodes in $V_{o}$ that are mapped to external nodes of $d$, attachment nodes of $o$, and the ones mapped to internal nodes, removal nodes of $o$. Two occurrences $o_{1},o_{2}$ of the same digram $d$ are called overlapping if $o_{1}\cap o_{2}\neq\emptyset$. Otherwise they are non-overlapping. If there are at least two non-overlapping occurrences of $d$ in a graph $g$, we call $d$ an active digram.

Let $A$ be a symbol of rank $k$ and $d$ a digram of rank $k$. The replacement of an occurrence $o$ of $d$ in $g$ by $A$ is the graph obtained from $g$ by removing the edges in $o$ from $g$, removing the removal nodes of $o$, and adding an edge labeled $A$ that is attached to the attachment nodes of $o$, in such a way that applying the rule $A\rightarrow d$ yields the original graph. Consider again Figure 10: the start graph of the right grammar is the replacement of the shaded occurrence of $d$ in the left graph by $A$ (where $d$ is $\mathsf{rhs}(A)$ of the grammar on the right).

4.3 The Algorithm

Given a graph $g$, gRePair first performs the steps given in Algorithm 1. As an additional step after the loop finishes, we connect the disconnected components of the graph by virtual edges and run the algorithm again before pruning (and in a final step remove the virtual edges from the grammar). This improves the compression on graphs with disconnected components. We now provide more details on the steps in lines 5 and 12, and on the pruning step.

4.3.1 Counting Occurrences (Step 5)

We aim to find a set of non-overlapping occurrences of a digram that occurs in $g$, that is of maximal size. As stated in the Introduction, this can be solved in $O(|E|^{4})$ time. This is done by reducing it to maximum matching: Let $g$ be a graph with $n$ nodes and $m$ edges, and $d$ a digram. The first step is to compute a set $O$ containing all occurrences of $d$ in $g$, including overlapping ones. This already takes $O(m^{2})$ time, as $|O|\in O(m^{2})$. To see this, consider a “star”; a graph with one central node connected to $m$ other nodes, which in turn have no neighbors except the central node. There are $m(m-1)/2$ pairs of edges and thus as many overlapping occurrences of the same digram. We encode this set of occurrences into a graph $g_{O}$ such that every occurrence $\{e_{1},e_{2}\}$ in $O$ is represented by an edge from $e_{1}$ to $e_{2}$ in $g_{O}$. Thus, $g_{O}$ potentially has a node for every edge in $g$, and an edge for every occurrence in $O$. It can be shown that a maximum matching (i.e., a maximal cardinality set of edges $X$ such that no two edges $e_{1},e_{2}\in X$ have a common node) on $g_{O}$ corresponds to a maximal non-overlapping subset of $O$. Computing a maximum matching in graphs can be done in $O(|V|^{2}|E|)$ by using, e.g. the Blossom-algorithm [13]. As $g_{O}$ has $O(m)$ nodes, and $|O|$ edges, the total running time is in $O(m^{2}|O|)=O(m^{4})$.

Doing the above for one digram is already prohibitively expensive. Thus we approximate. Let $\omega$ be an order on the nodes of $g$. We traverse the nodes of $g$ in this order, and at every node iterate through occurrences centered around this node, as detailed in the next section below. The node order $\omega$ heavily influences the compression behavior. Consider the graph in Figure 11. We want to find the non-overlapping occurrences of the first digram in Figure 8. Note that all three nodes are external, that is, we are looking for three nodes $u,v,w$ such that $u$ has an edge to $v$, $v$ has an edge to $w$, and all three nodes also have edges to other nodes (different from $u,v,w$). Figure 11a shows the non-overlapping occurrences found if we start in the central node of the graph. Using the DFS-type order starting at a different node given by the numbers in Figure 11b, three occurrences are determined. Using the “jumping” order in Figure 11c, a maximum set of four non-overlapping occurrences is found. Note that for strings and trees, maximum sets of non-overlapping occurrences can be obtained in linear time using left-to-right and post order, respectively, and assigning occurrences in a greedy way.

Our implementation offers a choice of four different orders, as explained in Section 4.5.1. Implementation details of this step are given in Section 4.6.1.

4.3.2 Updating Occurrence Lists (Step 12)

Let $o$ be an occurrence of $d$ that is being replaced and let $F$ be the set of edges in $g$ that are incident with the attachment nodes of $o$. Removing $o$ from the graph can only affect the occurrence lists of digrams that have occurrences using edges in $F$. In particular, for the two edges in $o$ ($e_{1}$ and $e_{2}$) we need to remove every occurrence that either $e_{1}$ or $e_{2}$ participate in from the corresponding occurrence list. To do this efficiently, we store a list of digrams with every edge for which the edge appears in an occurrence. After the replacement let $e^{\prime}$ be the new $A$-labeled nonterminal edge in $g$. Then every pair of edges $\{e^{\prime},e\},e\in F$ is an occurrence of a digram, and is thus inserted into the appropriate occurrence list (and the frequency counts are updated accordingly). The last step has again complexity issues. Let $k$ be the sum of degrees of all attachment nodes of $o$. Then there are $O(k)$ pairs of edges to be considered as occurrences with the new nonterminal edge. This is not a problem in itself, but consider the following situation: let there be an attachment node $v$ with degree $k$. Further, let every one of the $k$ edges around $v$ be part of a distinct occurrence of the digram $d$ being replaced. As explained, when replacing one of these occurrences, the other $k-1$ edges are considered as occurrences with the new nonterminal. Now however, when replacing the next one, the remaining $k-2$ edges have to be considered again. Thus, during all the replacement steps, we would again need to consider $O(k^{2})$ occurrences. To solve this issue, we consider first the case of a graph without edge labels and directions. Let node $v$ have degree $k$, i.e., there are $O(k^{2})$ edge pairs that are occurrences of some digram. After inserting one of them into the occurrence list, we take the two edges involved out of further consideration, because every other occurrence using one of them would overlap with this one. Let $E$ be the edges incident with $v$ that have not been added into occurrence lists yet. We partition $E$ into two sets $E_{1}=\{e_{1},\ldots,e_{n}\}$ and $E_{2}=\{f_{1},\ldots,f_{m}\}$ where $m-n\in\{0,1\}$. We then add ${\mathsf{Occ}}(E_{1},E_{2})=\{\{e_{i},f_{i}\}\mid 1\leq i\leq n\}$ as the occurrences around $v$ to the list. Note that only if all occurrences around $v$ are occurrences of the same digram, this procedure guarantees to produce a maximum non-overlapping set of occurrences around $v$.

From here, adding labels (or directions, which can be viewed as labels) is straightforward. For two labels $\sigma_{1}$ and $\sigma_{2}$ let $E_{\sigma_{1},\sigma_{2}}(v)$ be the set of edges incident with $v$ labeled $\sigma_{1}$ and not yet added to an occurrence list for a digram with an edge labeled $\sigma_{2}$. Then for distinct symbols $\sigma_{1}$ and $\sigma_{2}$ add the occurrences ${\mathsf{Occ}}(E_{\sigma_{1},\sigma_{2}}(v),E_{\sigma_{2},\sigma_{1}}(v))$ and for every $\sigma$ add the occurrences where both edges have the same symbol by splitting $E_{\sigma,\sigma}(v)$ as above. This takes $O(|\Sigma|^{2})$ time (where $|\Sigma|$ is expected to be small).

The above method works during the initial traversal, however every time an occurrence of a digram is replaced, the occurrence lists of affected digrams need to be updated. After inserting the new nonterminal edge $e^{\prime}$ we need to select an edge $e$ from the set of neighboring edges $F$ to make an occurrence of a new digram. This can again lead to a situation where time quadratic in the node degree is necessary, unless this selection is done in constant time. Our implementation does this by storing a list of available edges for every pair of edge labels attached to every node of the graph. For every edge label the first edge $e$ in the respective list is selected to create the occurrence $\{e^{\prime},e\}$. This takes $O(|\Sigma|)$ time.

4.3.3 Pruning

As mentioned in Section 4.1, pruning can reduce the size of a grammar. For string grammars, pruning removes every nonterminal that is referenced only once in the grammar. The presence of parameters for tree grammars, or external nodes for HR grammars, complicates the pruning step. While, every nonterminal only referenced once can be removed just like before, it is then possible to still have nonterminals which are referenced more than once but do not contribute to the compression (this is not the case for strings). To see this, consider the following tree grammar (from [36, Example 8]):

[TABLE]

In this grammar $A$ and $B$ are each referenced twice, but do not “contribute” to compression. To see this, note that the grammar above has size 12 and consider the grammars obtained by removing either nonterminal (left: after removing $A$, right: after removing $B$):

[TABLE]

These grammars now have sizes 11 and 12, respectively. Clearly, both rules where therefore not contributing in the full grammar above, as neither grammar is now larger than before. However, removing $A$ first did make the grammar smaller than it was before. Further, if we were to remove one more nonterminal, we would in both cases get the original tree

[TABLE]

which is still of size $12$. This shows that the $A$ rule was still not contributing after removal of the $B$-rule, but the $B$-rule turns into a contributing rule if the $A$-rule is removed first. Thus the order in which the nonterminals are removed may also affect the quality of the pruning. Finding an optimal order is a complex optimization problem as mentioned in [36, Section 3.2].

Let us consider pruning for SL-HR grammars. For a nonterminal $A$ of rank $n$ we define $\mathsf{handle}(A)=(\{v_{1},\ldots,v_{n}\},\{e\},\mathsf{lab}(e)=A,\mathsf{att}(e)=v_{1}\cdots v_{n},\mathsf{ext}=v_{1}\cdots v_{n})$. The contribution of $A$ is defined as

[TABLE]

where $\mathsf{ref}(A)=|\{e\in E_{S}\mid\mathsf{lab}(e)=A\}|+\sum_{B\in N}|\{e\in E_{\mathsf{rhs}(B)}\mid\mathsf{lab}(e)=A\}|$ is the number of edges labeled $A$ in the grammar. The contribution of $A$ counts by how much the size of the grammar changes when every instance of the nonterminal is derived, i.e., it measures how much $A$ contributes towards compression. If $\mathsf{con}(A)>0$ then we say that $A$ contributes towards compression. The grammar in Figure 12 represents the graph of Figure 11. Here, the $A$-rule has $\mathsf{con}(A)=4\cdot(5-3)-5=3$ and thus contributes to the compression. The reader may verify that the sizes of this grammar and the graph (given in Figure 13, with the IDs assigned as explained in Section 3.1) differ by exactly three. Note that, as we remove rules, the contribution of other nonterminals might change as edges are added or deleted. Therefore, the effectiveness of pruning depends on the order in which the nonterminals are considered. For TreeRePair, a bottom-up hierarchical order works well in practice. We use a similar approach. First every nonterminal $A$ with $\mathsf{ref}(A)=1$ is removed, because, by definition, they do not contribute towards compression. The order does not matter for this step. To remove $A$ we apply its rule to each $A$-edge in the grammar and remove the $A$-rule. Then we traverse the nonterminals in bottom-up $\leq_{\mathsf{{NT}}}$-order (see Preliminaries), removing each nonterminal with $\mathsf{con}(A)\leq 0$.

4.4 Relation to Compression of Strings and Trees

Our algorithm is a generalization of previous RePair-variants for strings [28] and trees [36]. Let $w$ be a string, and $d_{1},\ldots,d_{n}$ be the digrams that string-RePair would replace during its run on $w$. If we run gRePair on $\mathsf{s\text{-}graph}(w)$, and use a left-to-right node order, then the digrams $d_{1}^{\prime},\ldots,d_{n}^{\prime}$ that gRePair replaces are exactly $\mathsf{s\text{-}graph}(d_{1})$ to $\mathsf{s\text{-}graph}(d_{n})$. Therefore, we obtain a graph-encoding of the same string-grammar that the original RePair generates. The comparison with TreeRePair is less clear. TreeRePair compresses ordered trees where the nodes, not the edges, are labeled from a finite alphabet. For gRePair to compress trees in the same way, we need to represent the tree as a tree-graph as given in Section 3.2 and use a similar postOrder-traversal as TreeRePair does. We can experimentally confirm that gRePair achieves comparable (within the same order of magnitude) compression ratios as TreeRePair.

An SL tree grammar achieves compression by representing only once repeating connected subgraphs of the given tree. An SL-HR grammar is more general, because it can share repeating disconnected subgraphs. Does this allow, for an SL-HR grammar, to compress a tree more effectively than any SL tree grammar? We show that this is not the case by proving that every SL-HR grammar $G$ that represents a tree (string), can be converted to an SL-HR grammar, that is only slightly larger than $G$ and for which every right-hand side is a tree (string). This is not trivial, as the expressive power of graph grammars is higher than the one of context-free string grammars. For example, it is possible to generate the language $\{\mathsf{s\text{-}graph}(w)\mid w=a^{n}b^{n}c^{n},n\in\mathbb{N}\}$ using HR grammars, but the string-language represented here is not context-free. We call an SL-HR grammar $G$ tree generating, if $\mathsf{val}(G)$ is a tree-graph as defined in Section 3.2. Similarly, $G$ is called string-generating, if $\mathsf{val}(G)$ is a string-graph. Recall that a path from a node $u$ to a node $v$ in a hypergraph is a tuple $(e_{1},\ldots,e_{n})$ of edges, which connect $u$ to $v$, such that an edge of rank $k$ is considered to have one source (the first attached node) and $k-1$ target nodes, and that we call a path internal, if it uses only internal nodes (with the possible exception of $u$ and $v$). For example, in Figure 14 the right-hand side of $A$ has a path $(C,B)$ from the green to the red node, but it is not an internal path, because it crosses the orange node.

Definition 5**.**

Let $g$ be a graph with the set $X$ of external nodes. Then the line-structure $\mathsf{ls}(g)=(X,E)$ is the directed, unlabeled graph such that for all $u,v\in X,(u,v)\in E$ if and only if there is an internal path from $u$ to $v$ in $\mathsf{val}(g)$.

For a nonterminal $A$ of an SL-HR grammar we denote $\mathsf{ls}(\mathsf{rhs}(A))$ by $\mathsf{ls}(A)$. For an example of a line-structure, see Figure 14. Note that if a grammar $G$ is tree-generating, $\mathsf{ls}(A)$ is always a rooted forest for every nonterminal $A$ in $G$ (otherwise there would be a cycle in $\mathsf{val}(A)$, because $G$ is tree-generating and $A$ is useful). We refer to this property by (LG). However, the right-hand side of $A$ may not be a tree-graph itself, as in the $A$-rule in Figure 14. There are two ways in which $\mathsf{rhs}(A)$ for a rule in a tree-generating grammar can not be a tree-graph: it can contain cycles, or nodes with multiple parents. Both of these cases can only happen with nonterminal edges, however. The line-structure is a tool to split these nonterminal edges, such that the resulting graphs are tree-graphs.

Theorem 6**.**

Let $G=(N,P,S)$ be a tree-generating SL-HR grammar. We can construct an SL-HR grammar $G^{\prime}=(N^{\prime},P^{\prime},S^{\prime})$ such that

$\mathsf{val}(G^{\prime})=\mathsf{val}(G)$, 2. 2.

$|G^{\prime}|\leq 2|G|$, and 3. 3.

$\mathsf{rhs}_{G^{\prime}}(A)$* is a tree-graph for every $A\in N^{\prime}\cup\{S^{\prime}\}$.*

Proof.

We describe three transformations on $G$, which yield the desired grammar $G^{\prime}$. In the first transformation, the set of nonterminals remains unchanged. We use the line-structure to order the external nodes in a top-down way, i.e., if $u$ is an ancestor of $v$ within the line-structure, then $u$ should be ordered before $v$. Let $\mathsf{ls}(A)=(V,E)$ for some nonterminal $A$, and let $u,v\in V$. We define the partial order $\prec_{A}$ such that $u\prec_{A}v$ if and only if there is a directed path from $u$ to $v$ in $\mathsf{ls}(A)$. Due to the property (LG) mentioned above, $\prec_{A}$ is well-defined. Let $(A,g)$ be a rule, and $u,v$ two of its external nodes, such that $u\prec_{A}v$, but $v$ appears before $u$ in $\mathsf{ext}_{g}$. We reorder $\mathsf{ext}_{g}$ (and by extension, the attachment relation of every nonterminal edge labeled $A$ in the entire grammar) such that they are sorted according to some (arbitrary, but fixed) total order consistent with $\prec_{A}$. This step does not change the structure of the grammar or affect its size. As an example, consider $\mathsf{ls}(X)$ for $X\in\{A,B,C\}$ in Figure 14. In all three cases, the red external node, needs to come first to be consistent with $\prec_{X}$, but it is currently third. The orange and green nodes can be ordered arbitrarily after that. Permissible orders for $\mathsf{ext}$ thus are red $<$ orange $<$ green or red $<$ green $<$ orange (see Figure 15 for the final grammar).

In the next two steps, additional nonterminals are (in general) added to the set of nonterminals. We iterate over $N$ in a bottom-up fashion, i.e., in reverse $\leq_{\mathsf{{NT}}}$-order. If we encounter an $A\in N$ such that $\mathsf{ls}(A)$ has at least two connected components $g_{1},\ldots,g_{k}$ then we add rules $(A_{i},h_{i})$ for $i\in[k]$, where $A_{i}$ is a new nonterminal of rank $|V_{g_{i}}|$, and $h_{i}$ is a subgraph of $\mathsf{rhs}(A)$. Note that $\sum_{i\in[k]}A_{i}=\mathsf{rank}(A)$. The set of nodes of $h_{i}$ is defined as

[TABLE]

i.e., $U_{i}$ contains the nodes of $\mathsf{rhs}(A)$ that can be reached from the external nodes in $g_{i}$. The set of edges of $h_{i}$ contains every edge of $\mathsf{rhs}(A)$, which is attached only to nodes in $U_{i}$. Let $w=a_{1}\cdots a_{n}$ be a string and $X=\{x_{1},\ldots,x_{m}\}\subseteq[n]$ a set of indices. By $w|X$ we denote the string $a_{x_{1}}\cdots a_{x_{m}}$ such that $x_{1}<x_{2}<\cdots<x_{m}$. We define the set of $i$-indices as

[TABLE]

Using this, we define $\mathsf{ext}[i]=\mathsf{ext}_{\mathsf{rhs}(A)}|\mathsf{idx}[i]$, and for some edge $e$ labeled $A$ we define $\mathsf{att}[i](e)=\mathsf{att}(e)|\mathsf{idx}[i]$. Now, we replace every occurrence of an edge $e$ labeled $A$ within the grammar by $k$ edges, such that for $i\in[k]$ the edge $e_{i}$ is labeled $A_{i}$ and attached to the nodes $\mathsf{att}[i](e)$. We remove the nonterminal $A$ and its rule from the grammar. Not that now all right-hand sides are tree graphs. Note further that $\sum_{i\in[k]}\mathsf{rank}(e_{i})=\mathsf{rank}(e)$, and $\sum_{i\in[k]}|h_{i}|\leq|\mathsf{rhs}(A)|$ and therefore the size of the new grammar is at most $|G|$.

In the third step we eliminate rules that have external nodes, which are neither root nor leafs. To do so, we again split the rules up. Let $(A,g)$ be a rule which has at least three external nodes $u,v,w$ such that there is a path from $u$ to $v$ and from $v$ to $w$, i.e., $v$ is an inner node and not root or leaf. Let $g_{1},\ldots,g_{k}$ be the maximally sized subgraphs of $g$, such that their union is $g$, and for every $i\in[k]$, $g_{i}$ is a tree-graph which does not have a triple of external nodes $u,v,w$ such that paths exist from $u$ to $v$ and $v$ to $w$, i.e., every external node of $g_{i}$ is either a root or a leaf. Let $e$ be an $A$-labeled edge of the grammar and let $\mathsf{ext}[i]$ and $\mathsf{att}[i](e)$ be defined as above. Now we again replace $(A,g)$ by the rules $(A_{1},g_{1}),\ldots,(A_{k},g_{k})$ and every nonterminal edge $e$ with $\mathsf{lab}(e)=A$ by the edges $e_{1},\ldots,e_{k}$, where $\mathsf{lab}(e_{i})=A_{i}$ and $\mathsf{att}(e_{i})=\mathsf{att}[i](e)$. In this case, an external node that is neither root nor leaf will appear in more than one of the graphs $g_{1},\ldots,g_{k}$, thus this step increases the size of the grammar. This can be bounded by

[TABLE]

The factor $2$ comes from the fact that, in the worst case, we may split at every external node. Thus the node- and edge-sizes are at most doubled. Therefore, for the grammar $G^{\prime}$ we have $|G^{\prime}|\leq 2|G|$. ∎

As an example, we provide in Figure 15 the conversion of the rules presented in Figure 14. We first adjust the order of the external nodes to one consistent with $\prec_{X}$ for $X\in\{A,B,C\}$ by using red $<$ orange $<$ green as the order of the external nodes in all three cases. Thus, the first external node becomes the third one, and the third external node becomes the first one. In the same way, the appropriate nonterminal edges ($B$ and $C$ in $\mathsf{rhs}(A)$) have their attachment relation reordered. We then apply the second step, splitting the $C$-rule into two rules $C_{1}$ and $C_{2}$. In this case the conversion was already finished after the second step, thus the new rules are not larger than the original ones (in fact, they are smaller, because the $C_{2}$-edge now is of rank $2$, which counts as size 1).

Consider again Theorem 6. It clearly follows from the construction of $G^{\prime}$ that $V_{S^{\prime}}=V_{S}$. This allows us to easily transfer the result also to string-graphs. Let $G$ be a string-generating SL-HR grammar. Recall that $G$’s start graph $S$ has two external nodes (because it generates a string-graph), and note that every nonterminal of $G$ has rank $\geq 2$. We convert $G$ into a tree-generating SL-HR grammar by making the second external node $v$ in $S$ internal. The resulting grammar generates a monadic tree, and we can use the result of Theorem 6 to convert it into a grammar, where every right-hand side is a monadic tree-graph (of rank 2). Finally, this grammar can be converted back into a string-generating grammar, by again making $v$ external.

Corollary 7**.**

Let $G=(N,P,S)$ be a string-generating SL-HR grammar. We can construct an SL-HR grammar $G^{\prime}=(N^{\prime},P^{\prime},S^{\prime})$ such that

$\mathsf{val}(G^{\prime})=\mathsf{val}(G)$, 2. 2.

$|G^{\prime}|\leq 2|G|$, and 3. 3.

$\mathsf{rhs}_{G^{\prime}}(A)$* is a string-graph for every $A\in N^{\prime}\cup\{S^{\prime}\}$.*

4.5 Important Parameters

In this section we describe some parameters of our algorithm that influence the compression ratio. Their effect is evaluated experimentally in Section 5.

4.5.1 Node Order

As discussed before the node order heavily influences the digram counting, which in turn influences the compression behavior. A node order $<_{V}$ is given by a bijective function $f:V\rightarrow[|V|]$ such that $u<_{V}v$ if $f(u)<f(v)$. Some of the orders below are modeled by functions $g:V\rightarrow[k]$ for some $k<|V|$, i.e., there exist nodes $u,v$ such that $g(u)=g(v)$, but a strict order is needed to run the algorithm. For this reason, we consider sets of functions $F=\{f:V\rightarrow[|V|]\mid\forall u,v\in V:f(u)<f(v)\Rightarrow g(u)\leq g(v)\}$ to be an admissible set of orders. This means, that whenever we state that a node order was used, we actually use an arbitrary order out of the set of admissible orders. We evaluate these orders:

natural order (nat) uses the node IDs as given in the source graph, 2. 2.

BFS order follows a breadth-first traversal, 3. 3.

FP computes a fixpoint on the node neighborhoods starting from the degrees, and 4. 4.

FP0, which is a degree order.

Formally, the natural order is just the identity. In the case of BFS there exists an additional element of nondeterminism. We choose as the first node $v$ (i.e., the one with $f(v)=1$) any node of lowest degree. For any other node $u$ the function $g(u)$ evaluates to the length of a shortest path from $v$ to $u$. This forms the basis for an admissible set of orders. Note that, for graphs with more than one connected component, one node $v$ has to be picked for every connected component. All of these initial nodes evaluate to $1$ by $g$. We now define the FP and FP0 orders. For a graph $g$ let $c_{i}:V_{g}\rightarrow\mathbb{N}$ be a family of functions that color every node with an integer. We first define $c_{0}(v)=d(v)$, where $d(v)$ is the degree of $v$. This is the order FP0. Now we map every node $v$ to the tuple $f_{0}(v)=(c_{0}(v),c_{0}(v_{1}),\ldots,c_{0}(v_{n}))$, where $v_{1},\ldots,v_{n}$ are the neighbors of $v$ ordered by their values in $c_{0}$. We sort these tuples lexicographically and let $c_{1}(v)$ be the position of $f_{0}(v)$ in this lexicographical order. This process is iterated until $c_{i+1}=c_{i}$. Now $c_{i}$ can be used as a basis for an admissible set of orders. This computation of the order works for undirected, unlabeled graphs, but can be straightforwardly extended to directed labeled graphs. We call this order FP. Figure 16 shows an example of the FP-order. The graph on the left is annotated by $c_{0}$, the graph in the middle shows $f_{0}$, which is then ordered lexicographically to get $c_{1}$ on the right. This is the fixpoint for this graph.

Note that it is not necessarily a strict order and thus also implies an equivalence relation on the nodes ($v\cong_{\text{FP}}u$ if and only if $c_{i}(v)=c_{i}(u)$). The number of equivalence classes of $\cong_{\text{FP}}$ has an interesting correlation with the compression ratio of gRePair, as discussed in Section 5.2.2.

4.5.2 Maximal Rank

The maximal rank is a user defined parameter of gRePair that specifies the maximal rank of a digram (and thus the maximal rank of a nonterminal edge) that the compressor considers. Digrams with a higher rank are ignored and not counted. It was shown already for TreeRePair [36, Theorems 9 and 10] that choosing this parameter too high or too small can have strong effects on compression (in both directions). The two families of trees given there, can be converted into families of graphs showing the same relation to the maximal rank for gRePair. We briefly recap the arguments, but as the proof details are almost identical to the case for TreeRePair, we do not repeat them here.

High Rank

Let $g_{n,k}$ be the graph $\mathsf{t\text{-}graph}(s_{n,k})$, where $s_{n,k}$ is a tree consisting of a right comb of $2^{n}$ nodes labeled $f_{k}$, a symbol of rank $k$. The first $k-1$ children of these nodes are leaves labeled $a$, the last child is the next $f_{k}$-labeled node (except for the last of these, which only has $a$-children). This is the same tree as given in [36, Theorem 9]. The size of $g_{n,k}$ depends on $k$: for $k=1$ the $f$-edges are of rank 2 (i.e., size 1) and thus we get $|g_{n,1}|=2^{n}+2^{n}+1$. For $k>1$ the size of each $f$-edge is $k+1$ and thus $|g_{n,k}|=2^{n}\cdot(k+1)+2^{n}+1$.

Lemma 8**.**

Given $g_{n,k}$ gRePair produces a grammar of size $O(k^{2}+n)$ if the maximal rank allowed is at least $k$, and does not compress at all if the maximal rank is less than $k$.

It is easy to see that there can be no compression with a maximal rank less than $k$: $g_{n,k}$ does not contain occurrences of any digram with a rank smaller than $k$. Once the allowed rank is at least $k$, gRePair reduces the width of the tree by $1$ with every iteration by combining one of the $a$-leaves with its $f_{k}$-/nonterminal parent. Finally a line of $2^{n}$ nonterminal edges remains, which all have the same label and can be compressed exponentially. This argument is identical to the one in the proof of [36, Theorem 9], only the notation changes to the one used for graphs.

Small Rank

We give an example of graphs which gRePair compresses best, if the maximum rank is limited to $2$. Our example is similar to the one TreeRePair [36, Theorem 10]. The main difference is that we use a graph with $2^{n}$ edges labeled $f$, instead of nodes. Let $T_{n}$ be a graph over $\Sigma=\{f,a_{0},a_{1},a_{2},a_{3},a_{4}\}$ with $2^{n+1}+2$ nodes $\{0,\ldots,2^{n+1}+1\}$ and $2^{n+1}$ edges $\{e_{1},\ldots,e_{2^{n+1}}\}$. The attachment relation is defined as $\mathsf{att}(e_{i})=i-1\cdot i$ for $i\in\{1,\ldots,2^{n}\}$, and $\mathsf{att}(e_{i})=i-2^{n}\cdot i$ for $i\in\{2^{n}+1,\ldots,2^{n+1}+1\}$. They are labeled by $\mathsf{lab}(e_{i})=f$ for $i\in\{1,\ldots,2^{n}\}$ and

[TABLE]

for $i\in\{2^{n}+1,\ldots,2^{n+1}\}$. This graph is a tree consisting of a path of $2^{n}$ edges labeled $f$, and every node attached to one of these $f$-edges, is also attached to an edge labeled $a_{0}$, $a_{1}$, $a_{2}$, $a_{3}$, or $a_{4}$. These edges appear in this order, i.e., if a node is attached to an edge labeled $a_{i}$, then the previous node (one $f$-edge up in the tree) is labeled $a_{i-1}$ ($\bmod 5$), and the next node (one $g$-edge down in the tree) is labeled $a_{i+1}$ ($\bmod 5$). The size of $T_{n}$ is $2^{n+2}+2$.

Lemma 9**.**

Given $T_{n}$, gRePair produces a grammar of size $O(n)$ if the maximal rank is restricted to $2$ and compresses at best to $75\%$ of the original size if the maximal rank is unbounded.

The argument for this is mostly identical to [36, Theorem 10]. With a maximal rank of $2$ it compresses well, because gRePair then only has limited choice in digrams. It will first replace the pairs of $f$- and $a_{l}$-labeled ($0\leq l\leq 4$) edges, because every other possible digram has a rank greater than $2$. After this is done, a string-graph remains that can now be compressed exponentially. If the maximal rank is unrestricted, the digrams of higher rank (pairs of $2$ $f$-edges in the first iteration) occur more frequently and are thus replaced by gRePair. This will replace all the $f$-edges, but all of the nodes remain in the start graph. Furthermore, in the next step, pairs of nonterminal edges will be replaced as the most frequent digram, again without sharing any nodes. This continues until, after the last iteration, the start graph still has all $2^{n+1}+2$ nodes, and all the edges labeled $a_{l}$ for $0\leq l\leq 4$. Furthermore, it has 2 nonterminal edges of rank $2^{n-1}$. Thus,

[TABLE]

Regardless of the rules and the pruning step, $|S|$ is already larger than $|T_{n}|$. In particular note that, not counting the nonterminal edges, the size of $S$ is still $x=2^{n+1}+2^{n}+4$. Therefore

[TABLE]

The pruning step reduces the grammar’s size, but the nodes and terminal edges in the start graph remain. Thus, the compression ratio cannot be better than $3/4$. Note that for TreeRePair the compression with unbounded rank is at best $50\%$ instead of $75\%$. The reason for this is, that the size definition for trees only counts edges, whereas we consider nodes and edges in graphs.

4.6 Implementation Details

In this section we describe some of the technical details of our implementation. We outline the involved data structures, and describe our output format.

4.6.1 Data Structures

Our data structures are a direct generalization to graphs of the data structures used for strings [28] and trees [36, Figure 11]. The occurrences are managed using doubly linked lists for every active digram. Of importance is a priority queue, which uses the frequency of a digram as the priority. Following Larsson and Moffat [28] the length of this queue is chosen as $\sqrt{n}$, where $n$ is the number of edges of the original input graph to gRePair.

4.6.2 Grammar Representation

We encode the start graph and the productions in different ways. As an example, consider again the grammar in Figure 12. The start graph is encoded using $k^{2}$-trees [5], using $k=2$ as this provides the best compression. This data structure partitions the adjacency matrix into $k^{2}$ squares and represents it in a $k^{2}$-ary tree. Consider the left adjacency matrix in Figure 17. The $9\times 9$-matrix is first expanded with 0-values to the next power of two; i.e., $16\times 16$. If one partition has only [math]-entries, a leaf labeled [math] is added to the tree. This happens for the 3rd and 4th partition in this case (the partitions are numbered left to right, top to bottom as indicated in the bottom center of the figure). Thus the 3rd and 4th child of the root are [math]-leafs. The other two have at least one $1$-entry, therefore inner nodes labeled $1$ are added and the square is again partitioned into $k^{2}$ squares. This is continued at most until every square covers exactly one value. At this point the values are added to the tree as leafs. As we need to consider edges with different labels, we use a method similar to the representation of RDF graphs proposed in [1]. Let $E_{\sigma}\subseteq E$ be the set of all edges labeled $\sigma$. For every label $\sigma$ appearing in $S$ we encode the subgraph $(V,E_{\sigma})$. If $\mathsf{rank}(\sigma)=2$, then this is encoded as an adjacency matrix. Otherwise we use an incidence matrix, i.e., a matrix that has one row for every edge and a column for every node. Thus, a 1 in row $i$, column $j$ of the incidence matrix means, that edge $i$ is attached to node $j$. All of these matrices are encoded as $k^{2}$-trees. Figure 17 is an example with two edge labels. Note that this example only uses edges of rank $2$. For a hyperedge $e$, the incidence matrix only provides information on the set of nodes attached to $e$, but not the specific order of $\mathsf{att}(e)$. For this reason we also store a permutation for every edge to recover $\mathsf{att}(e)$. We count the number of distinct such permutations appearing in the grammar and assign a number to each. Then we store the list encoded in a $\lceil\log n\rceil$-fixed length encoding, where $n$ is the number of distinct permutations.

For the productions we use a different format, as we expect the right-hand-sides to be very small graphs (due to pruning, they may be larger than just a digram). We store an edge list for every production, encoding the nodes using a variable-length $\delta$-code [14]. One more bit per node is used to mark external nodes. As the order of the external nodes is also important, we make sure that the order induced by the IDs of the external nodes is the same as the order of the external nodes. Every production begins with the edge count (again, using $\delta$-codes). For every edge we first use one bit to mark terminal/nonterminal edges, then store the number of attached nodes, followed by the $\delta$-codes of the list of IDs. Finally, we also use a $\delta$-code for the edge label. For the production in Figure 12 this leads to the following encoding:

[TABLE]

This is a bit sequence of length 28.

4.7 On the Choice of Grammar Formalism

We discuss briefly the reasoning for some of our choices regarding the grammar formalism used. This includes the choice of hyperedge replacement over a different replacement method, and the restrictions we further enforce on hypergraphs.

4.7.1 Hyperedge vs. Node Replacement

There are two well-known types of context-free graph grammars:

• •

context-free hyperedge replacement grammars (HR grammars for short, see [17]), and

• •

context-free node replacement grammars (NR grammars for short, see [16]).

In terms of graph language generating power, NR grammars are strictly more expressive than HR grammars. For instance, NR grammars can describe the set of all complete graphs, whereas this is not possible with HR grammars. If we use NR grammars to produce bipartite graphs that encode hypergraphs, then the resulting hypergraph language generating power is exactly the same as that of HR grammars (see [17, Theorem 4.28]). Note that for any given SL-HR grammar one can construct an equivalent SL-NR grammar of similar size.

The difference in expressive power comes due to node replacement grammars using a different formalism for derivation. Instead of merging external nodes with the nodes in the nonterminals neighborhood, every rule in an NR-grammar includes a connection relation, which specifies, which nodes in the rule are to be connected to which nodes in the nonterminal’s neighborhood. Consider as an example the grammar given in Figure 18: the initial graph $S$ has two nonterminal nodes, both labeled $A$. The rule for $A$ has two nonterminal nodes labeled $B$, and the connection relation $\{(A,B),(C,B),(D,B),(a,B)\}$. When deriving one of the $A$-nodes in $S$ we note that the neighborhood of this node consists of only one node with label $A$. The tuple $(A,B)$ in the connection relation means that every $A$ node from the nonterminals neighborhood is connected with every $B$-node in the rule. Figure 19 shows this, and one more derivation step as an example.

The natural choice to define a digram for use of RePair with NR-grammars would be two neighboring nodes and the edge between them. However, due to the connection relation, we would also need to include the neighborhood in this definition, as different occurrences of the same two nodes may need different connection relations. These may be incompatible with each other in some cases, or could be merged into one rule in others. This could make digrams too specific, and occurrences somewhat rare. It is therefore unclear, whether the use of node replacement yields a successful RePair variant, but we note that it is interesting future work, particularly as we believe, that complete graphs can be compressed much better using NR grammars.

Conjecture**.**

Let $C_{n}$ be a complete graph with $2^{n}$ nodes. Then there exists an SL-NR grammar $G_{n}$ such that $\mathsf{val}(G_{n})=C_{n}$, and $|G_{n}|\in O(n)$, but there is no SL-HR grammar $G_{n}^{\prime}$ such that $\mathsf{val}(G_{n}^{\prime})=C_{n}$ and $|G_{n}|\in O(n)$.

The previously mentioned grammar in Figure 18 is an example for an SL-NR grammar that compresses a complete graph as in the conjecture and can be extended to generate $C_{n}$ for any $n$. The connection relation for this grammar could also use a shorthand (i.e., $\{(*,a)\}$ could be used for the connection relation of the $D$-rule instead of $\{(A,a),(B,a),(C,a),(D,a)\}$). Doing so yields a grammar with $n$ rules, each having two nodes, one edge, and one tuple in the connection relation. We currently have no proof for the second part of the conjecture.

4.7.2 On the Conditions (C1) and (C2)

Recall, we also enforce two conditions on hypergraphs, which are not always found in the literature:

• (C1)

for every edge $e$: $\mathsf{att}(e)$ contains no node twice, and

• (C2)

the string $\mathsf{ext}$ of external nodes contains no node twice.

We refer to these as att-, and ext-distinctness, respectively. We also call a rule att-distinct (ext-distinct), if its right-hand side is att-distinct (ext-distinct). A grammar is att-distinct (ext-distinct), if every rule and the start graph are att-distinct (ext-distinct). As already mentioned in Section 3 these conditions have no effect on the graph language generating power of HR grammars (provided the graphs do not require edges/external nodes that are not att/ext-distinct). For efficiency reasons gRePair does not consider or produce edges that are not att-distinct. This potentially weakens the compression, as nonterminal edges that are not att-distinct could be used to represent occurrences of different digrams using only one rule. For example, consider the digrams g) in Figure 8. Occurrences of them could also be replaced by a rule using the digrams a) from that same figure, by merging the center and right-most external nodes. This is not necessarily always an improvement: in this case we are using a rank-3 nonterminal edge, where a rank-2 edge would have sufficed, thus storing larger nonterminals. It can be shown however, that there are grammars, which are not att-distinct, but smaller than the smallest att-distinct grammar for the same graph. Figure 20 is an example for such a graph. We leave it as an exercise to calculate the maximal impact of att-distinctness with respect to compression. For ext-distinctness, on the other hand, we can show that the condition not only has no effect on compression, but enforcing it makes the grammar smaller.

Lemma 10**.**

Given a non-ext-distinct SL-HR grammar $G=(N,P,S)$, an ext-distinct SL-HR grammar $G^{\prime}$ can be constructed (in linear time), such that $L(G^{\prime})=L(G)$ and $|G^{\prime}|<|G|$.

Proof.

For a string $w$ let $\mathsf{symb}(w)$ be the set of symbols appearing in $w$, and $\mathsf{dist}(w)$ the string $v$ derived from $w$ by only keeping the first occurrence of every distinct symbol in $w$. For example, for $w=acbac$, $\mathsf{symb}(w)=\{a,b,c\}$, and $\mathsf{dist}(w)=acb$. Let $(A,g)$ be a rule that is not ext-distinct. We first add a new rule $(A^{\prime},g^{\prime})$ with $\mathsf{rank}(A^{\prime})=|\mathsf{dist}(\mathsf{ext}_{g})|$, and $g^{\prime}$ is the same graph as $g$ except with $\mathsf{ext}_{g^{\prime}}=\mathsf{dist}(\mathsf{ext}_{g})$. Then we replace the $A$-rule by $(A,h)$ where $h=(\mathsf{symb}(\mathsf{ext}_{g}),\{e\},\mathsf{lab}(e)=A^{\prime},\mathsf{att}(e)=\mathsf{dist}(\mathsf{ext}_{g}),\mathsf{ext}=\mathsf{ext}_{g})$. We can now derive every occurrence of $A$ in the grammar and remove the $A$-rule altogether. Doing this merges some of the nodes in the grammar, as they were referenced by the same external node. Note that this process reduces the size of the grammar. Let $u$ be a node that occurs $k\geq 2$ times in $\mathsf{ext}_{g}$. Then, applying the $A$-rules decreases the node size by $k-1$. The edge-size also decreases by $k-1$, as $A^{\prime}$ has a smaller rank. ∎

5 Experimental results

We implemented a prototype in Scala (version 2.11.7) using the Graph for Scala library222http://www.scala-graph.org/ (version 1.9.4). The experiments are conducted on a machine running Scientific Linux 6.6 (kernel version 2.6.32), with 2 Intel Xeon E5-2690 v2 processors at 3.00 GHz and 378 GB memory. As we are only evaluating a prototype, we do not mention runtime or peak memory performance, as these can be largely improved by a more careful implementation. We compare to the following compressors:

• •

$k^{2}$-tree, for which we use our own Scala-implementation following the description in [5], using the same binary format, however without the further optimization on compressing the leaf-level described there.

• •

The list merge (LM) algorithm by Grabowski and Bieniecki [24]. We use $64$ for their chunk size parameter, as in their paper.

• •

The combination of dense substructure removal [6] and $k^{2}$-tree by Hernández and Navarro [27] (HN). For the parameters to the algorithm we use $T=10$, $P=2$, and $ES=10$, which are the parameters their experiments show to provide the best compression. Note that this compressor uses a $k^{2}$-tree implementation with all the optimizations.

The latter two implementations were provided by the authors. We also experimented with RePair on adjacency lists by Claude and Navarro [10], but omit the results here, because on all graphs we tested, stronger compression was achieved by another compared compressor.

As common in graph compression, we present the compression ratios in bpe (bits per edge). Note that our compressor reorders the nodes. We omit the space required to retain the original node IDs, because we assume that they represent arbitrary data values and it is possible to update this mapping. This is particularly true for RDF graphs, as explained in Section 5.3.2.

Note that it is known that using different node orders will change the results for all of these compressors, including gRePair. We discussed the importance of the traversal order, but another area where the node order will have an effect is the final encoding of the start graph using the $k^{2}$-tree-structure. To get comparable results, we use the natural order in all cases, when it comes to the encoding. We ran experiments, where the start graph of the grammar produced by gRePair was reordered according to the initially computed FP-order. This improves some of the results, but we consider it future work to test the impact of different orders on the encoding of the start graph (cf the conclusions).

5.1 Datasets

We use three different types of graphs: network graphs (Table 1), RDF graphs (Table 2), and version graphs (Table 3). Each table lists the numbers of nodes and edges and the number of equivalence classes of $\cong_{\text{FP}}$ (see Section 4.5.1) of each graph. For RDF graphs we also list the number of edge labels (i.e., predicates) of each graph. Two of the version graphs also have labeled edges.

We give a short description of each graph: the network graphs are from the Stanford Large Network Dataset Collection333http://snap.stanford.edu/data/index.html and are unlabeled. They are communication networks (Email-EuAll, Wiki-Vote, Wiki-Talk), a web graph (NotreDame) and Co-Authorship networks (CA-AstroPh, CA-CondMat, CA-GrQc). Even if they were advertised as undirected, we considered all of them to be lists of directed edges, to improve the comparability with the other compressors, as these would also assume the input graph to be directed.

The RDF graphs mostly come from the DBPedia project444http://wiki.dbpedia.org/Downloads2015-04, which is an effort of representing ontology information from Wikipedia. We evaluate on specific mapping-based properties (English), which contains infobox data from the English Wikipedia and mapping-based types, which contains the rdf:types for the instances extracted from the infobox data. We use three different versions of the latter: types for instances extracted from the Spanish and Russian Wikipedia pages that do not have an equivalent English page, and types for instances extracted from the German Wikipedia pages that do have an equivalent English page. The Identica-dataset555http://www.it.uc3m.es/berto/RDSZ/ represents messages from the public stream of the microblogging site identi.ca. Its triples map a notice or user with predicates such as creator (pointing to a user), date, content, or name. The Jamendo-dataset666http://dbtune.org/jamendo/ is a linked-data representation of the Jamendo-repository for Creative Commons licensed music. Subjects are artists, records, tags, tracks, signals, or albums. The triples connect them with metadata such as names, birthdate, biography, or date.

Version graphs are disjoint unions of multiple versions of the same graph. Here, Tic-Tac-Toe represents winning positions, and Chess represents legal moves777Both from http://ailab.wsu.edu/subdue/download.htm. The files contain node labels from a finite alphabet, which we ignore here. DBLP60-70 and DBLP60-90 are co-authorship networks from DBLP, created from the XML888http://dblp.uni-trier.de/xml/ (release from August 1st, 2015) file by using author IDs as nodes and creating an edge between two authors who appear as co-authors of some entry in the file. To make version graphs, we created graphs containing the disjoint union of yearly snapshots of the co-authorship network.

5.2 Influence of Parameters

We evaluate how the different parameters for our compressor affect compression. For these experiments every parameter except the one being evaluated is fixed for the runs. Note that this sometimes leads to situations where none of the results in a particular experiment represents the best compression our compressor is able to achieve for the given graph. The parameters evaluated are the maximum rank of a nonterminal and the node order.

5.2.1 Maximum Rank

We test maxRank values from 2 up to 8. The average results for the three types of graphs tested are given in Table 4, as compression in bpe. We did some tests for higher values (up to 16) but only got worse results. The best results are marked in bold. For each class of graphs, a value of $4$ achieved the best results on average. We therefore conclude that a value of $4$ is a good compromise for our data sets.

5.2.2 Node Order

Recall from Section 4.5.1 that the FP-order is a fixed point computation starting from the node degrees. As this is an iterative process, it can be terminated at any point. We were interested how much difference a fixpoint makes compared to using just the node degrees (${\text{FP}}0$). Figure 21 shows the compression ratio of a selection of graphs under the different node orders. The selection aims to be representative for the graphs of the types we evaluated: CA-graphs behave similar to CA-AstroPh, version graphs similar to DBLP60-70, and the RDF graphs similar to Specific properties en. The other graphs in the figure are chosen because they are outliers in their respective category. Our FP-order achieves the best result on almost all of the graphs. On RDF graphs the order generally had only marginal impact: the best and worst results usually are within 0.5 bpe of each other. The Jamendo graph presents an exception here, with the natural order being about 1 bpe better than the closest other result and featuring the largest difference between ${\text{FP}}0$ and FP of all our graphs. Version graphs however benefit hugely from the FP-order, as further discussed in Section 5.3.3. This shows that two or more versions of the same graph are similarly ordered in the FP-order, increasing the likelihood of the compressor of recognizing repeating structures.

There is another interesting observation about the FP-order, or in particular the equivalence relation $\cong_{\text{FP}}$. It is likely that nodes with a high similarity, i.e., the same neighborhood up to a certain distance, are equivalent in this relation. This implies that graphs with a low number of equivalence classes should compress well, as they would have many repeating substructures. Figure 22 shows this correlation. There is no graph in the lower right corner, i.e., there is no graph with a low number of equivalence classes and low compression.

5.3 Comparison with other Compressors

We compare gRePair with the compressors $k^{2}$-tree, LM, and HN listed at the beginning of Section 5. Note that we compare RDF graph compression only against the $k^{2}$-tree-method, as LM and HN have not been extended to RDF graphs. While these algorithms all work as in-memory data structures, they produce outputs with file sizes comparable to the in-memory representations. We measure the compression performance based on these file sizes. Where applicable, we furthermore use the dense substructure removal done as a first step in the HN-method (see Section 2) in combination with our compressor, marked as “gRePair+DSR”. To do so, we added specially labeled rank-1 edges to the virtual nodes created by the dense substructure removal, to ensure that the original graph could be restored. Usually, the virtual nodes are identified by having an ID greater than the largest ID occurring in the original graph. As our compressor reorders the nodes, this is no longer feasible, and marking them with additional edges was the most space-efficient method we found.

Let us give an idea of the compression ratio for the graphs according to our size definition. Using gRePair (without DSR), we achieve, on average, a compression ratio ($\frac{|G|}{|g|}$) of

• •

$68\%$ for network graphs,

• •

$35\%$ for RDF, and

• •

$24\%$ for version graphs.

The parameters we choose for gRePair are $\text{maxRank}=4$ and the FP-order, both being generally the best choice for our dataset. We note that in most results the majority of the file sizes of gRePair’s output ($>90\%$) is for the $k^{2}$-tree representation of the start graph.

5.3.1 Network Graphs

Our results on network graphs compared to $k^{2}$-tree, LM, and HN are summarized in Figure 23. We improve on the plain $k^{2}$-tree-representation on all graphs but NotreDame. However, our results are often slightly worse than LM and HN, with Email-EuAll and CA-GrQc being exceptions. That being said, dense substructure removal can be combined with our compressor, using their dense substructure removal as a preprocessing step. This generally improves on our results and achieves the smallest bpe-values for two of the three CA-graphs.

5.3.2 RDF Graphs

Recall from Section 2.2 that the values for subject, predicate, and object of RDF triples are commonly mapped to integers using a dictionary to represent the original values. As in this way dictionary and graph are separate entities, we only focus on compressing the graph. Any method for dictionary compression can be used to additionally compress the dictionary (e.g. [45]) and we omit the space necessary for the dictionary.

Our results in comparison to $k^{2}$-tree are given in Table 5. We greatly improve against this representation. For the graphs 2 – 4 (in particular 2 and 3) we are able to produce a representation that is orders of magnitude smaller than the $k^{2}$-tree-representation (note that $|[\cong_{\text{FP}}]|$ is very low for these graphs). For these two graphs in particular, this is due to the majority of their nodes being laid out in a star pattern: a few hub nodes of very high degree are connected to nodes, most of which are only connected to the hub node. Furthermore, while not acyclic, the graphs are also very tree-like. Structures like these are compressed well by gRePair, because every iteration of the replacement-round of gRePair roughly halves the number of edges around the hub node.

5.3.3 Version Graphs

We describe several experiments over version graphs. First we study how the compressor behaves given a high number of identical copies of the same simple graph. The graph in this case is a directed circle with four nodes and one of the two possible diagonal edges. Figure 24a shows the results of this experiment for identical copies starting from 8 going in powers of 2 up to 4096. Clearly, gRePair is able to compress much better in this case (“exponential compression”), while the file size of other methods rises with roughly the same gradient as the size of the graph. Note that both axes in this graph use a logarithmic scale: in this case, gRePair produces a representation that is orders of magnitude smaller than the other compressors.

Except for identical copies of rather simple graphs, however, we cannot expect to achieve exponential compression on version graphs. Every version has changes and it is not easy to decide which parts of two versions remain the same and can thus be compressed using the same nonterminals. Even if we can guarantee that the same (i.e., isomorphic) substructures are consistently compressed in the same way, the changes between versions might be too big to allow for exponential compression. Our FP-order is inspired by the Weisfeiler-Lehman method [53] (see also [8]), which approximates a test for isomorphism. The results on version graphs, when comparing different orders (see also Section 5.2.2 above), suggest that this is indeed exploited. Figure 24b shows a comparison on the compression of a version graph from the DBLP co-authorship network. We started with a co-authorship network including publications from 1960 and older. To this graph we then add versions with the publications from 1961, 1962,…until 1970 and compress the graphs obtained in this way. The comparison shows that using the FP-order our method achieves better compression than using other orders. Note that the results for BFS or random order are much closer to $k^{2}$-trees. Our full results for version graphs are given in Table 6. Note that we compare Tic-Tac-Toe and Chess only against $k^{2}$-tree, because these graphs have edge labels. The results show that gRePair compresses version graphs well.

5.4 Results on Synthetic Graphs

We finally describe experiments on synthetic graphs. These show some of the effects described earlier, namely that

some graphs can be compressed exponentially, 2. 2.

the maximal rank can have a big impact, and 3. 3.

different node orders can have a big influence on the compression.

We evaluate two different families of graphs: “grid” and “triangle fractal”. Both have a parameter $n\in\mathbb{N}$ to achieve different sizes. Let $\mathsf{grid}_{n}$ be an $n\times 2^{n}$-grid graph, i.e., a graph with $n\cdot 2^{n}$ nodes where node $i$ has edges to $i+1$ (unless $i\equiv 0\mod{2^{n}}$), and to $i+2^{n}$ (unless $i+2^{n}>n\cdot 2^{n}$). Following this construction, $\mathsf{grid}_{n}$ has $n\cdot 2^{n}$ nodes, and $(n-1)\cdot 2^{n}+n\cdot 2^{n-1}$ edges, yielding a size of $|\mathsf{grid}_{n}|=n(2^{n}+2^{n-1})+(n-1)\cdot 2^{n}$. Furthermore we define a triangle fractal in the following way: initially $\mathsf{tf}_{1}$ is a complete graph with $3$ nodes. To define $\mathsf{tf}_{i}$ with $i>1$, we start with $\mathsf{tf}_{i-1}$ and let $X$ be the set of edges in $\mathsf{tf}_{i-1}$ that are incident to a node of degree $2$. For each edge $e$ in $X$ we add a new node $v$ and add edges from both ends of $e$ to $v$, creating another triangle. Intuitively, we add another triangle at every outer edge. Regarding the size, $t_{n}$ has $|t_{n}|_{V}=2^{n}+2^{n-1}$ nodes, and $|t_{n}|_{E}=2|t_{n}|_{V}-3$ edges. The natural order (i.e., the order of the node-IDs) is a top-to-bottom, left-to-right order for $\mathsf{grid}_{n}$, while the natural order for $\mathsf{tf}_{n}$ is to start with the three nodes of the innermost triangle and then go outward from there in the same way as generated (i.e., in “layers”).

Table 7 lists the results for these graphs using various orders, graph sizes, and values of maxRank. Here we state the compression performance in relation to the size definition, i.e., compression ratio is given by $\frac{|G|}{|g|}$ (in percent), where $G$ is the compressed representation of $g$.

Some notable results: triangle fractal compresses best at $\text{maxRank}=2$. This is not surprising, as in this case the construction of the graph is exactly reversed (with respect to the recursive definition of $\mathsf{tf}_{n}$). However, note that at $\text{maxRank}=4$ the results are still very close using the FP-order, whereas they get noticeably worse for every other order. Indeed, with the BFS-order even for $\text{maxRank}=2$ the optimal result is not found any more. Using a higher rank than 4 is generally detrimental for this graph, because digrams of higher rank occur more often than the ones of rank 2. This is not a problem in itself, as carefully chosen occurrences can still be reduced well, but there are many more sets of occurrences for rank-3 digrams, than there are for rank-2 digrams. Which one is found by gRePair depends on the node order. This graph family shows that

maxRank can have a huge impact (compare 2 vs. 4 for the natural order), and 2. 2.

the node order can have a huge impact (compare FP vs. BFS order).

Grids are the opposite, when it comes to maxRank: best compression is achieved for unbounded rank, while $\text{maxRank}=2$ gives almost no compression (independent of the node order). For unbounded rank, ${\text{FP}}0$ gives close to no compression, FP compresses to $34\%$, and natural order compresses to $12\%$ (for $n=12$). The latter “exponential compression” is achieved, by treating the grid as $n$ identical lines of length $2^{n}$. Node orders that traverse the grid in such a way (like the natural order, which goes row by row, or the BFS-order which follows the rows “in parallel”), are likely to find digram occurrences corresponding to this structure. Accordingly, the BFS-order also achieves good compression, in particular, it has the best result for $\text{maxRank}=15$ with $n=8$ or $n=12$. Note however, that for $\mathsf{grid}_{12}$ with BFS-order and unbounded maxRank the rank was actually bounded to $1500$, because the computation takes too long otherwise.

6 Query Evaluation

In this section we investigate two types of queries that can be performed over SL-HR grammars: neighborhood queries and speed-up queries. Neighborhood queries allow to traverse the edges of a graph (in any direction). Using them, any arbitrary graph algorithm can be performed on the compressed representation given by an SL-HR grammar. However, this comes at a price: a considerable slow-down is to be expected in comparison to running over an uncompressed graph representation, because a partial decompression is required in order to obtain the neighboring nodes. In contrast, speed-up queries, as their name suggests, can run faster on an SL-HR grammar than on an uncompressed graph representation. Examples of speed-up queries are counting the number of connected components of the graph, checking regular path properties in the graph, or checking reachability between two nodes. These queries can be evaluated in polynomial time over the grammar, and allow speed-ups proportional to the compression ratio. The results in this section have not been implemented. Over grammar-compressed trees, the performance of simple speed-up queries is evaluated in [40].

6.1 Neighborhood Queries

For a node $v\in V_{g}$ of a hypergraph $g$ we denote by $N(v)=\{u\in V_{g}\mid\exists e\in E_{g}:u,v\in\mathsf{att}_{g}(e)\}$ the neighborhood of $v$. For simple graphs we also define $N^{+}(v)=\{u\in V_{g}\mid\exists e\in E_{g}:\mathsf{att}(e)=uv\}$ and $N^{-}(v)=\{u\in V_{g}\mid\exists e\in E_{g}:\mathsf{att}(e)=vu\}$, the incoming and outgoing neighborhoods of $v$, respectively. Furthermore we let $E(v)=\{e\in E_{g}\mid v\in\mathsf{att}(e)\}$ be the set of edges incident with $v$.

Let $G=(N,P,S)$ be an SL-HR grammar. We assume that every right-hand side in $P$ contains at most two nonterminal edges (but arbitrarily many terminal edges). This can be achieved by replacing pairs of nonterminal edges with a single new one: for $n>2$ let $e_{1},\ldots,e_{n}$ be the nonterminal edges in $\mathsf{rhs}(A)$ for some $A\in N$. Then replace $e_{2},\ldots,e_{n}$ by a new edge $e_{B}$ with $\mathsf{att}(e_{B})=\mathsf{att}(e_{2})\cdots\mathsf{att}(e_{n})$, $\mathsf{lab}(e_{B})=B\notin N$ and $\mathsf{rhs}(e_{B})$ is a graph containing $n-1$ nonterminal edges such that replacing $e_{B}$ generates the original $\mathsf{rhs}(A)$. This procedure can recursively be applied until every right-hand side has at most two nonterminal edges. This increases the size of the grammar by at most a factor of 2.

Recall that the nodes in the start graph $S$ are numbered $1,..,m$ and that there is an order on the nonterminal edges $e_{1},\dots,e_{\ell}$ in $S$ so that the nodes in $g_{1}=\mathsf{val}(e_{1})$ are numbered $m+1,\dots,m+v_{1}$, where $v_{1}=|g_{1}|_{V}$, and similarly, nodes in $g_{i}=\mathsf{val}(e_{i})$ are numbered from $k=m+\sum_{j=1}^{i-1}v_{j}$ to $k+v_{i}$. Given a node ID, i.e., a number in $k\in\{1,\dots,|\mathsf{val}(G)|_{V}\}$, computing its outgoing neighbors consists of two steps:

compute a grammar representation ($G$-representation) of $k$, and 2. 2.

from a $G$-representation, compute the outgoing neighbors (as IDs in the decompressed graph) of the represented node.

A $G$-representation is a path in the derivation tree of $G$ that “derives the node $k$”. Such a path is of the form $wv$ where $w$ is a (possibly empty) string of the form $e_{0}e_{1}\cdots e_{n}$. If $w$ is empty, then $v$ must be a node in $S$. If not, then $e_{0}$ is a nonterminal edge of $S$. If $A_{1}$ is the label of $e_{0}$, then $e_{1}$ is a nonterminal edge in $\mathsf{rhs}(A_{1})$ labeled $A_{2}$, etc. Finally, $v$ is an internal node in $\mathsf{rhs}(A_{n})$. Let $\ell$ be the number of nonterminal edges in $S$ and $h=0pt(G)$. The $G$-representation of $k$ can be computed using Algorithm 2, where $\#\mathsf{nodes}(A)$ refers to the number of internal nodes in $\mathsf{val}(A)$. The complexity of this algorithm depends on the specific implementation of Steps 5 and 6, and the computation of $\#\mathsf{nodes}(A)$. Specifically, it is possible to precompute $\#\mathsf{nodes}(A)$ for every $A\in N$ and the first ID of every edge in $S$ (Step 6). Doing so needs an additional $O(|N|+\ell)$ space, but now Step 5 can be implemented using a binary search and only needs $O(\log\ell)$ time. Ignoring the preprocessing, a computation of Algorithm 2 takes $O(\log(\ell)+h)$ time and $O(|N|+|E_{S}|)$ space. If we do not want to use the additional space, a computation of $\#\mathsf{nodes}(A)$ takes $O(h)$ time (it can be done bottom-up). Steps 5 and 6 can now be implemented using a linear search through the nonterminal edges of $S$ in their derivation order as defined in Section 3.2. This leads to a total running time of $O(|E_{S}|h+h^{2})$. In the following we refer to the runtime of Algorithm 2 by $\nu$ to reflect this ambiguity.

Given the $G$-representation $e_{0}e_{1}\cdots e_{n}v$, the outgoing neighbors are computed using Algorithm 4. This algorithm uses the function getID, detailed in Algorithm 3. The complexity of the latter again depends on the implementation of Step 15 and $\#\mathsf{nodes}(A)$. By the same reasoning as above we get a runtime of $\nu$ for getID. Finally getOutNeighborhood uses $O(\nu\cdot n)$ time, where $n$ is the out-degree of the node represented by $e_{0}e_{1}\cdots e_{n}v$ within $\mathsf{val}(G)$. Note that for the algorithms to be well defined, they have to work with $e_{1}\cdots e_{n}=\varepsilon$. In this case, we implicitly assume $e_{n}=S$ and $\mathsf{rhs}(\mathsf{lab}(e_{n}))=S$, i.e., we are working on the startgraph.

Proposition 11**.**

Let $G$ be an SL-HR grammar and $k\in\{1,\dots,|\mathsf{val}(G)|_{V}\}$. Let $n$ be the number of in (or out) neighbors of $k$ in $\mathsf{val}(G)$. The node IDs of these $n$ nodes can be computed in time $O(\nu n)$.

Note that for string grammars, data structures have been presented that guarantee constant time per move from one letter to the next (or previous) [22]. This result has been extended to grammar-compressed trees [39], and we hope that it can also be generalized to SL-HR grammar-compressed graphs.

6.1.1 Speed-Up Queries

One attractive feature of straight-line context-free grammars is the ability to execute finite automata over them without prior decompression. This was first proved for strings (see [32]) and was later extended to trees (and various models of tree automata, see [37]). The idea is to run the automaton in one pass, bottom-up, through the grammar. As an example, consider the grammar $S\to AAA$ and $A\to ab$ from the Introduction, and an automaton $\mathcal{A}$ that accepts strings (over $\{a,b\}$) with an odd number of $a$’s. Thus, $\mathcal{A}$ has states $q_{0},q_{1}$ (where $q_{0}$ is initial and $q_{1}$ is final) and the transitions $(q_{0},a,q_{1})$, $(q_{1},a,q_{0})$, and $(q,b,q)$ for $q\in\{q_{0},q_{1}\}$. Since the actual active states are not known during the bottom-up run through the grammar, we need to run the automaton in every possible state over a rule. For the nonterminal $A$ we obtain $(q_{0},A,q_{1})$ and $(q_{1},A,q_{0})$, i.e., running in state $q_{0}$ over the string produced by $A$ brings us to state $q_{1}$, and starting in $q_{1}$ brings us to $q_{0}$. Since $S$ is the start nonterminal, we are only interested in starting the automaton in its initial state $q_{0}$. We obtain the run $(q_{0},A,q_{1})(q_{1},A,q_{0})(q_{0},A,q_{1})$, i.e., the automaton arrives in its final state $q_{1}$ and hence the grammar represents a string with odd number of $a$’s. It should be clear that the running time of this process is $O(|Q||G|)$, where $Q$ is the set of states of the automaton, and $G$ is the grammar.

Unfortunately, for graphs there does not exists an accepted notion of finite-state automaton. Nevertheless, properties that can be checked in one pass through the derivation tree of a graph grammar have been studied under various names: “compatible”, “finite”, and “inductive”, and it was later shown that these notions are essentially equivalent [26]. Courcelle and Mosbah [11] show that all properties definable in “counting monadic second-order logic” (CMSO) belong to this class, and by their Proposition 3.1, the complexity of evaluating a CMSO property $\psi$ over a derivation tree $t$ can be done in $O(|t|\eta)$, where $\eta$ is an upper bound on the complexity of evaluation on each right-hand side of the rules in $t$. This is done by a bottom-up computation on the nodes of $t$, where every node $u$ can use the results of its children to achieve a correct computation for the subtree rooted at $u$.

Proposition 12**.**

Let $\psi$ be a fixed CMSO property. For a given SL-HR grammar $G$ it can be decided in $O(|G|\eta)$ time whether or not $\psi$ holds on $\mathsf{val}(G)$, where $\eta$ is an upper bound on the time needed to evaluate one right-hand side of the grammar.

Note that we state the time complexity based on $|G|$ instead of $|t|$. This needs an adjustment of the proof, as the derivation tree $t$ cannot be explicitly constructed, because it may be exponentially larger than $G$. However, a derivation DAG (directed acyclic graph) still retains all information necessary for the algorithm stated in [11] to work. It has a hierarchy, that makes the bottom-up computation possible, and the while there is ambiguity in the parent relationship, the children for every node are well defined. A computation for one right-hand side depending on the results of that computation on the children in the derivation tree, can therefore be done in the derivation DAG as well.

Note that Proposition 12 is often stated under a fixed tree decomposition $t$ of width $k$ of the graph $g$ and then simply becomes $O(|g|)$. The CMSO (or compatible or finite) graph properties have been extended to functions from graphs to natural numbers, see e.g., Section 5 of [11]. They can be evaluated with a similar complexity as in Proposition 12. For the same explanation as above, this result can be applied to SL-HR grammars. Without stating this result explicitly, we mention some of the well-known CMSO functions: (1) maximal and minimal degree, (2) number of connected components, (3) number of simple cycles, (4) number of simple paths from a source to a target, and (5) maximal and minimal length of a simple cycle.

Beware that $\eta$ in Proposition 12 need not be linear in the size of a right-hand side, but is rather a generic upper bound. Courcelle and Mosbah [11] show (for their Proposition 3.1) linearity for evaluations using a certain Boolean algebra, and cubic complexity for sets of cardinalities. For universal evaluation they give an exponential upper bound. Lohrey [33] proves that the problem in Proposition 12 becomes ${\mathsf{PSPACE}}$-complete for grammars where both the rank and the number of nonterminals per right-hand side are bounded by a constant. Without these restrictions the problem is complete for ${\mathsf{EXPTIME}}$. Note that ${\mathsf{PSPACE}}$-completeness is already true for explicitly represented graphs.

The specific complexity thus depends on the problem. We show for two problems that they can be solved in linear time with grammar-compressed graphs as input.

6.2 Reachability Queries

An important class of queries are reachability queries. For a given graph $g$ and nodes $u$ and $v$ such a query asks if $v$ is reachable from $u$, i.e., if there exists a path from $u$ to $v$ in $g$. It is well known that this problem can be solved in $O(g)$ time (e.g., by doing a BFS-traversal in $O(|V|+|E|)$ time). How can we solve this problem on an SL-HR grammar $G$? Certainly, $(u,v)$-reachability is CMSO definable and therefore Proposition 12 gives us an upper bound of $O(|G|^{2})$. The following direct linear time algorithm essentially uses the same method already applied by Lengauer and Wanke [30]. Their formalism is slightly different from ours however, as it uses an encoding of the hypergraphs using bipartite graphs, and the algorithm as stated only decides reachability in undirected graphs. We therefore restate the algorithm using the following notion, which will again be used in the next section:

Definition 13**.**

Let $g$ be a graph with set $V$ of external nodes. Then the skeleton graph $\mathsf{sk}(g)=(V,E)$ is the directed, unlabeled graph such that for all $v,v^{\prime}\in V$, $(v,v^{\prime})\in E$ if and only if $v^{\prime}$ is reachable from $v$ in $\mathsf{val}(g)$.

The edges of a skeleton graph are computed as follows. First, assume that $g$ is a terminal graph. We determine the strongly connected components of $g$ in linear time (e.g., using Tarjan’s algorithm [50]). Let $g^{\prime}$ be the corresponding graph which has as nodes the strongly connected components of $g$. We remove from $g^{\prime}$ each strongly connected component $C$ that does not contain external nodes. This is done by inserting for every pair of edges $e_{1},e_{2}$ such that $e_{1}$ is an edge from a component $D\not=C$ into $C$ and $e_{2}$ is an edge from $C$ to a component $E\not=C$ (with $E\not=D$), an edge from component $D$ to component $E$. Finally, we replace each component by a cycle of the external nodes of that component, and, for an edge from a component $D$ to a component $E$ we add an edge from an arbitrary external node of $D$ to one of $E$.

Theorem 14**.**

Let $g$ be a graph and $G=(N,S,P)$ an SL-HR grammar with $\mathsf{val}(G)=g$. Given nodes $u,v\in V_{g}$, it can be determined in $O(|G|)$ time whether or not $v$ is reachable from $u$ in $g$.

Proof.

We first compute $G$-representations $u^{\prime}$, $v^{\prime}$ of $u$ and $v$ in $O(\log l+h)$ time, as described in Section 6.1. We traverse $G$ bottom-up with respect to $\leq_{\mathsf{{NT}}}$ in one pass and compute for each nonterminal $A$ its skeleton graph $\mathsf{sk}(A)$. After having computed in $O(|G|)$ time the skeleta for all nonterminals, we can solve a reachability query as follows. Let $S^{\prime}$ be the graph obtained from $S$ by replacing each nonterminal edge by its skeleton graph; clearly, it can be obtained in $O(|G|)$ time.

Case 1: Assume that $u^{\prime}$ and $v^{\prime}$ are of the form $u^{\prime\prime}$ and $v^{\prime\prime}$, i.e., both nodes are in the start graph. It should be clear that $v$ is reachable from $u$ in $\mathsf{val}(G)$ if and only if $v^{\prime\prime}$ is reachable from $u^{\prime\prime}$ in $S^{\prime}$. The latter is checked in $O(|S^{\prime}|)$ time.

Case 2: Let $u^{\prime}=e_{0}\cdots e_{n}u^{\prime\prime}$ and $v^{\prime}=f_{0}\cdots f_{m}v^{\prime\prime}$. Let $A_{i}$ be the label of $e_{i-1}$ for $i\in\{1,\dots,n\}$ and let $B_{j}$ be the label of $f_{j-1}$ for $j\in\{1,\dots,m\}$. We determine the set $E_{n}$ of external nodes of the right-hand side $h_{n}$ of $A_{n}$ that are reachable from $u^{\prime\prime}$ in $h_{n}$. This is done by replacing the (at most two) nonterminal edges in $h_{n}$ by their skeleton graphs, and then running a standard reachability test. We now move up the derivation tree (viz. to the left in $u^{\prime}$), at each step computing a subset $E_{i}$ of the external nodes of $\mathsf{sk}(A_{i})$: we locate the nodes corresponding $E_{i+1}$ in $\mathsf{sk}(A_{i})$ and determine the set $E_{i}$ of external nodes reachable from these. Finally, we obtain a set $E_{0}$ of nodes in $S^{\prime}$ (all incident with the edge $e_{0}$). In a similar way we compute a set $F_{0}$ of nodes in $S$ that are incident with $f_{0}$ (and can reach $v^{\prime}$). Finally, we check if a node in $F_{0}$ is reachable from a node in $E_{0}$. This is done by adding edges over $F_{0}$ that form a cycle, and edges over $E_{0}$ that form a cycle. We now pick arbitrary nodes $f$ in $F_{0}$ and $e$ in $E_{0}$ and check if $f$ is reachable from $e$ in $S^{\prime}$. ∎

Furthermore, by Lengauer and Wagner [29] the reachability problem on grammar-compressed graphs is ${\mathsf{P}}$-complete.

6.3 Regular Path Queries

Regular path queries (RPQ) are a well-known (see, e.g., [54]) way to query graph data: the query is given as a regular expression $\alpha$ over the edge alphabet of the graph $g$. Given two nodes $u,v$ in $g$ the problem is to decide whether there exists a path from $u$ to $v$ such that its edge labels, taken as a string, match the regular expression $\alpha$. Such queries are of relevance in modern applications: version 1.1 of the SPARQL query-language999https://www.w3.org/TR/sparql11-query/, for RDF data, introduces property paths, which are a variant of regular path queries. It is well-known that the problem whether a regular path query holds for two given nodes in a graph is decidable in time $O(|g|\cdot|\mathcal{A}_{\alpha}|)$ where $\mathcal{A}_{\alpha}$ is an NFA deciding the language $L(\alpha)$ of $\alpha$. Such an automaton $\mathcal{A}_{\alpha}$ can be constructed in linear time and with $|\mathcal{A}_{\alpha}|\in O(|\alpha|)$, e.g., using Thompson’s construction [51]. The algorithm works as follows:

• •

Consider $g$ to be an NFA $\mathcal{A}_{g}$ with initial state $u$ and final state $v$.

• •

Construct the product automaton of $\mathcal{A}_{g}$ and $\mathcal{A}_{\alpha}$ deciding $L(\mathcal{A}_{g})\cap L(\alpha)$.

• •

Test the product automaton for emptiness.

If the final test is true, then there is no such path. Otherwise it exists and we say $u$ and $v$ satisfy $\alpha$. We generalize this method to grammar-compressed graphs. Given a grammar $G$ and a regular expression $\alpha$, we first compute an SL-HR grammar $G_{\alpha}$ which generates the graph-structure (ignoring initial and final states for now) of the product automaton of $\mathcal{A}_{\mathsf{val}(G)}$ and $\mathcal{A}_{\alpha}$. Then, using the result from the previous section, we decide reachability from the initial to the final state. To make this construction easier to read, we will relax one condition we enforced on hypergraphs before: nodes in the grammar are named not just by IDs, but by a tuple of ID and state. In fact, for a node-ID $i$ and a set of states $Q$, we generate nodes $(i,q)$ for every $q\in Q$. We refer to $i$ as the node’s ID, and $q$ as the node’s state. Consequently, this affects how nodes are named during a derivation step. The renaming $\rho$ for nodes $(i,q)$ always only affects the ID portion of the node, i.e., for any $q\in Q$ only renamings of the form $\rho((i,q))=(j,q)$ will be allowed. The rules by which the ID is renamed still follow the method laid out in Section 3.1. However, as there may now be distinct nodes $(i,q)$ and $(i,p)$ for two different states $q,p\in Q$, we also require that $\rho((i,q))=(j,q)$ and $\rho((i,p))=(j,p)$, i.e., nodes with the same ID will keep this property.

We recall some necessary definitions. A nondeterministic finite automaton (NFA) over an alphabet $\Sigma$ is a tuple $\mathcal{A}=(Q,\delta,q_{i},q_{f})$, where $Q$ is a finite set of states, $\delta\subseteq Q\times(\Sigma\cup\{\varepsilon\})\times Q$ is the transition relation, $q_{i}\in Q$ is the initial state, and $q_{f}\in Q$ is the final state. A tuple $(q,w)\in Q\times\Sigma^{*}$ is called a configuration of $\mathcal{A}$. A configuration $(p,v)$ can follow a configuration $(q,w)$, denoted $(q,w)\vdash(p,v)$, if

$w=\sigma v$ for some $\sigma\in\Sigma$ and $(q,\sigma,p)\in\delta$, or 2. 2.

$w=v$ and $(q,\varepsilon,p)\in\delta$.

We denote the transitive closure of $\vdash$ by $\vdash^{*}$. The language decided by $\mathcal{A}$ is denoted as $L(\mathcal{A})=\{w\mid(q_{i},w)\vdash^{*}(q_{f},\varepsilon)\}$. Let $\mathcal{A}=(Q,\delta,q_{i},q_{f})$ and $\mathcal{A}^{\prime}=(Q^{\prime},\delta^{\prime},q_{i}^{\prime},q_{f}^{\prime})$ be two NFA’s. By $\mathcal{A}\otimes\mathcal{A}^{\prime}=(Q_{\otimes},\delta_{\otimes})$ we denote the product construction defined by $Q_{\otimes}=Q\times Q^{\prime}$ and $\delta_{\otimes}=\delta_{\Sigma}\cup\delta_{\varepsilon}$, where

[TABLE]

Note that, while the product construction defines a system of state transitions, it does not set initial and final states by default. However, the NFA $(Q_{\otimes},\delta_{\otimes},(q_{i},q_{i}^{\prime}),(q_{f},q_{f}^{\prime}))$ does decide the language $L(\mathcal{A})\cap L(\mathcal{A}^{\prime})$. This property is used to decide whether there exists a path satisfying a regular path query between two given nodes. Such automata without initial/final states are also just called transition systems. The product construction still works if either or both the automata are transition systems. A simple graph $g=(V,E,\mathsf{att},\mathsf{lab},\mathsf{ext})$ with edge labels from $\Sigma$ defines a transition system $\mathsf{trans}(g)=(Q_{g},\delta_{g})$ with $Q_{g}=V$ and $\delta_{g}=\{(v,\sigma,u)\mid\exists e\in E:\mathsf{lab}(e)=\sigma$ and $\mathsf{att}(e)=vu\}$.

Consider the product construction of $\mathsf{trans}(g)$ and $\mathcal{A}$ for some simple graph $g$ and an NFA $\mathcal{A}$. It represents every possible run of $\mathcal{A}$ on any path within $g$, only by setting an initial and final state we choose specific start and end-nodes within $g$, and initial/final states of $\mathcal{A}$. Thus, for any two nodes $u,v$ of $g$ we can check whether there is a path between them that $\mathcal{A}$ accepts with the same product construction. We next extend this notion to SL-HR grammars representing simple graphs, by describing a construction which, given an SL-HR grammar $G$ and an NFA $\mathcal{A}$, generates an SL-HR grammar representing the product construction of $\mathsf{trans}(\mathsf{val}(G))$ and $\mathcal{A}$. Thus, we achieve a compressed representation of all runs of $\mathcal{A}$ on paths of $\mathsf{val}(G)$.

Lemma 15**.**

Given an SL-HR grammar $G=(N,P,S)$ that generates a simple graph and an NFA $\mathcal{A}=(Q,\delta,q_{i},q_{f})$, we can compute in $O(|G||\mathcal{A}|)$ time an SL-HR grammar $G_{\mathcal{A}}=(N_{\mathcal{A}},P_{\mathcal{A}},S_{\mathcal{A}})$, such that $\mathsf{trans}(\mathsf{val}(G_{\mathcal{A}}))=\mathsf{trans}(\mathsf{val}(G))\otimes\mathcal{A}$.

Proof.

The construction is straightforward: for every rule $p=(A,g)$ of $G$, the product construction of $g$ and $\mathcal{A}$ is computed. Due to this, the rank increases: if $\mathsf{rank}(g)=k$, then $\mathsf{rank}(g\otimes\mathcal{A})=k|Q|$. Accordingly, some care has to be taken with nonterminal edges, as these also increase in rank. They need to be attached to the same node-IDs as before, but once for every state in $Q$. To make sure that nodes attached to nonterminal edges and external nodes match up correctly, we enforce some (arbitrary) order on $Q$.

Let $Q=\{q_{1},\ldots,q_{n}\}$ and let $<_{Q}$ be a total order $q_{1}<_{Q}q_{2}<_{Q}\cdots<_{Q}q_{n}$ on $Q$. For a string $w=w_{1}\cdots w_{m}$ let $w\times Q$ be the string $(w_{1},q_{1})(w_{2},q_{1})\cdots(w_{m},q_{1})(w_{1},q_{2})\cdots(w_{m},q_{n})$. For every $(A,g)\in P$, $P_{\mathcal{A}}$ contains a rule $(A,g_{\otimes})$ defined as follows. Let $V_{\otimes}=V\times Q$ and

[TABLE]

such that

[TABLE]

For the external nodes we set $\mathsf{ext}_{\otimes}=\mathsf{ext}\times Q$. This defines the rules of $G_{\mathcal{A}}$. Clearly, we do not add any nonterminals, and thus have $N_{\mathcal{A}}=N$. Finally $S_{\mathcal{A}}$ is constructed from $S$ and $\mathcal{A}$ using the same construction as described above for the right-hand sides of the rules (i.e., $S_{\mathcal{A}}=S_{\otimes}$). ∎

It should be clear that $|G_{\mathcal{A}}|\in O(|G||\mathcal{A}|)$. It can now be used to decide regular path queries:

Theorem 16**.**

Given an SL-HR grammar $G$, where $\mathsf{val}(G)$ is a simple graph, an RPQ $\alpha$, and a pair of nodes $u,v$ from $\mathsf{val}(G)$, it can be decided in time $O(|\alpha||G|)$ whether $u$ and $v$ satisfy $\alpha$.

Proof.

First compute an NFA $\mathcal{A}$ from $\alpha$ by using Thompson’s well known construction [51]. Note that $|\mathcal{A}|\in O(|\alpha|)$. Using Lemma 15 compute the grammar $G_{\mathcal{A}}$ generating the product construction of $G$ and $\mathcal{A}$. Now, using Theorem 14, decide reachability from $(u,q_{i})$ to $(v,q_{f})$ in $\mathsf{val}(G_{\mathcal{A}})$. Note that $u,v$ are node-IDs in $\mathsf{val}(G)$, but a $G$-representation $e_{1}\cdots e_{n}i$ of $v$ can be converted into a $G_{\mathcal{A}}$-representation of $(v,q_{i})$ by using $e_{1}\cdots e_{n}(i,q_{i})$. If a path exists, we can conclude that there is a path from $u$ to $v$ satisfying the RPQ $\alpha$. Otherwise, it does not exist. ∎

As an example showing how powerful this construction is, consider the string $a^{40}$, which can be represented by a grammar as $a^{32}a^{8}$ and the obvious SL-HR grammar $G$ representing the string-graph encoding this string. The minimal NFA $\mathcal{A}$ deciding $L=\{a^{x}\mid x\bmod 5=0\}$ has 5 states. The product construction of $\mathsf{s\text{-}graph}(a^{40})$ and $\mathcal{A}$ would therefore have 205 states, whereas the grammar $G_{\mathcal{A}}$ only has 95 states, and just replacing the nonterminals with their skeleta in the small start graph (20 states), e.g., when testing for reachability between $(0,q_{i})$ and $(40,q_{f})$, immediately shows that there is an accepting run from the first to the last node (i.e., nodes [math] and $40$, respectively) of the graph.

We can also use this “product grammar” to decide a more general problem. In a way, the product construction encodes every pair of nodes that fulfills the query $\alpha$. Thus, the product grammar $G_{\mathcal{A}}$ is a compressed representation of every such pair. We can therefore decide, whether there exists a pair of nodes at all, that satisfies the query. Intuitively, this is done by computing, bottom-up, for every rule, which external nodes can be reached from any initial state, and from which external nodes a final state can be reached. If an external node appears in both these lists at some point, we know that there is a path between some initial and final state.

Theorem 17**.**

Given an SL-HR grammar $G$, where $\mathsf{val}(G)$ is a simple graph, and an RPQ $\alpha$, it can be decided in time $O(|\alpha||G|)$, if there exist of nodes $u,v$ in $\mathsf{val}(G)$ satisfying $\alpha$.

Proof.

As before, construct $\mathcal{A}$ from $\alpha$, and $G_{\mathcal{A}}$ from $G$ and $\mathcal{A}$ according to Lemma 15. We now compute some helpful information in a bottom-up pass over the grammar, i.e., iterating over the rules in the reverse $\leq_{\mathsf{{NT}}}$-order. For a rule $(A,g)$ we first compute whether any node $(y,q_{f})$ can be reached from any node $(x,q_{i})$ (where $(x,q_{i})$ and $(y,q_{f})$ are nodes in $g$) within $\mathsf{val}(g)$, using the methods from Theorem 14. If this is the case, a pair satisfying $\alpha$ exists. Otherwise, we compute two sets of nodes $P_{A}$ and $Q_{A}$. Intuitively, $P_{A}$ contains the external nodes of $g$ that can be reached from some $(v,q_{i})$ (an initial state) while $Q_{A}$ contains the external nodes of $g$ from which a node $(v,q_{f})$ (a final state) is reachable.

$P_{A}$ and $Q_{A}$ for a rule $(A,g)$ are computed in the following way: first we compute two sets of nodes, $X$ and $Y$. The set $X$ contains every node $x\in V_{g}$ with the following properties:

• •

there exists a nonterminal edge $e\in E_{g}$ such that $x\in\mathsf{att}(e)$, and

• •

if $x$ is on position $i$ in $\mathsf{att}(e)$, then the $i$th external node of $\mathsf{rhs}(\mathsf{lab}(e))$ is in $P_{\mathsf{lab}(e)}$.

The set $Y$ is defined analogously, but using $Q_{\mathsf{lab}(e)}$ instead of $P_{\mathsf{lab}(e)}$. Now we replace every nonterminal edge of $g$ by their skeleton (see Definition 13) and let this graph be $g^{\prime}$. To $g^{\prime}$ we add a new node $s$ and an edge from $s$ to every node in $\{(x,q_{i})\in V_{g}\mid x\in\mathbb{N}\}\cup X$. Every external node now reachable from $s$ belongs to the set $P_{A}$. This set can be computed by a single BFS-traversal starting in $s$. To compute $Q_{A}$ we add a new node $t$ to $g^{\prime}$ that has an edge from every node in $\{(x,q_{f})\in V_{g}\mid x\in\mathbb{N}\}\cup Y$. Every external node that can reach $t$ is part of $Q_{A}$. This can be computed by complementing all the edges and again starting a BFS traversal from $t$.

If, for any $A\in N$, $P_{A}\cap Q_{A}\neq\emptyset$, then a pair of nodes $u,v$ exists within $\mathsf{val}(A)$ such that they satisfy $\alpha$. Otherwise, we compute $X$ and $Y$ for the start graph $S_{\mathcal{A}}$, replace the nonterminals in $S_{\mathcal{A}}$ by their skeleta, and add both $s$ and $t$ to $S_{\mathcal{A}}$ as above. If $t$ is now reachable from $s$, then there exist nodes $u,v$ within $\mathsf{val}(G)$ satisfying $\alpha$. Otherwise no such nodes exist. ∎

Note that the constructions in this section all generalize to hypergraphs (instead of simple graphs) in a straightforward way. There is some ambiguity on how to define transition systems using hyperedges. We suggest to use a similar approach as for the definition of paths within hypergraphs (cf. Section 3). A hyperedge in a transition system would thus be considered as directed with one source node (the first one it is attached to) and multiple target nodes. Semantically, a rank $k$ ($k>2$) hyperedge labeled $\sigma$ and attached to nodes $v_{1}\cdots v_{k}$ would then be the same as $k-1$ simple edges all labeled $\sigma$, starting in $v_{1}$, and using $v_{2},\ldots,v_{k}$ as target nodes.

7 Conclusions

We present a generalization to (hyper)graphs of the RePair compression scheme as known for strings and trees. Our generalization produces from a given graph a straight-line hyperedge replacement grammar (SL-HR grammar). We prove some theoretical results about SL-HR grammars, for instance, if the given graph is a string or a tree, then an SL-HR grammar cannot compress much better than an ordinary string or tree grammar; thus, in these cases the use of graph grammars does not offer stronger compression than the existing native grammars. In terms of the RePair compression, we prove that (as for trees) the choice of the maximal rank of a grammar can heavily influence the compression behavior.

We then study an implementation of RePair. We observe that for graphs, finding a digram with a maximal number of non-overlapping occurrences is computationally hard; using state-of-the-art algorithms it requires at least cubic time. We therefore introduce an approximation which counts greedily and heavily depends on the order in which the graph is traversed. We experiment with several node orders and find that an order that generalizes the node degree order and is similar to the one used in the Weisfeiler-Lehman approximative isomorphism test [53] gives the best compression results. We compare our compressor to state-of-the-art graph compressors. Over network graphs (which have no edge labels), we do not obtain a conclusive answer: sometimes our compressor gives strongest compression, sometimes the other compressors do. Over RDF graphs (which are edge-labeled) our compressor gives the best results, sometimes factors of several magnitudes smaller than other compressors. We also obtain the best results for “version graphs” which are disjoint unions of versions of the same graph (which are very similar).

We prove that, as in the case of strings and trees, there exist interesting “speed-up” algorithms. Such algorithms can run faster on the compressed grammar than on the original, by a factor proportional to the compression ration of the grammar. We show that reachability between two given nodes offers such an algorithm, as well as evaluating regular path queries over two nodes. The latter asks if there exists a path so that the string of path labels matches a given regular expression. We show that even without a candidate pair of nodes given, we can determine within similar time bounds, whether or not there exists any pair of nodes in the original graph with a path between them matching the regular expression.

For future work, there are several paths to follow. It would be interesting to consider a RePair compression scheme for graphs that is based on node replacement (NR) graph grammars. NR graph grammars can compress some graphs, e.g. cliques, much stronger than HR grammars. On the other hand, rules of NR grammars are more complex and expensive to store. For our compressor, other node orders should be considered which can give rise to stronger compression. Especially for version graphs we believe that different orders could give better results; one possibility, for instance, is to compute the edit distance between two versions of a graph, and to use it to compute a node order that is beneficial for our RePair compressor. In terms of speed-up algorithms there is much work to be done. Foremost, we would like to implement our algorithms and show that they can be faster than existing state-of-the art graph databases. Fundamentally of utmost interest and importance is the study of the complexity of the isomorphism problem for SL-HR grammars. Can it be decided in polynomial time if two graphs represented by SL-HR grammars are isomorphic? For strings and trees similar results hold (see [32] and [7]), but note that even extending the latter result from (ordered ranked) trees to arbitrary trees is non-trivial [38] and that the complexity of deciding the isomorphism of two explicitly given graphs is currently not known to be polynomial.