Parsing Unranked Tree Languages, Folded Once ^†

Abstract

A regular unranked tree folding consists of a regular unranked tree language and a folding operation that merges (i.e., folds) selected nodes of a tree to form a graph; the combination is a formal device for representing graph languages. If, in the process of folding, the order among edges is discarded so that the result is an unordered graph, then two applications of a fold operation are enough to make the associated parsing problem NP-complete. However, if the order is kept, then the problem is solvable in non-uniform polynomial time. In this paper, we address the remaining case, where only one fold operation is applied, but the order among the edges is discarded. We show that, under these conditions, the problem is solvable in non-uniform polynomial time.

1. Introduction

Graphs are one of the most commonly used data structures in computer science. Whether we are conducting social network analysis [1], defining the semantics of programming languages [2], or devising a better method for training deep neural networks [3], we are likely to operate on some form of graph representation. Practical applications of formal graph languages typically require that the parsing problem is efficiently solvable. This means that given a graph g, we can decide whether the graph adheres to the formalism in polynomial time, and also produce a certificate attesting the veracity of our decision. In the case of so-called order-preserving DAG grammars (OPDGs), for example, we can decide in linear time if a given graph g is well-formed with respect to a particular grammar G, and provide a unique derivation tree for g in G as proof [4].

Significant effort has been devoted to finding graph formalisms that combine expressiveness with parsing efficiency (see, e.g., [5,6,7]). Most of these are restrictions of hyperedge replacement grammars (HRGs) [8], a natural generalisation of context-free grammars, in which nonterminals are replaced by labelled hyperedges that provide restricted access to the intermediate graphs. The previously mentioned OPDGs are one of the most easily parsed restrictions of HRGs. Like many other graph formalisms, they were designed to be just strong enough to represent so-called abstract meaning representations (AMRs), a semantic representation based on a limited type of directed acyclic graphs. The principles underlying AMRs were introduced by Langkilde and Knight [9] based on a semantic abstraction language by Kasper [10]. The notion was refined and popularized by Banarescu et al. [11] and instantiated for a limited domain by Braune et al. [12].

At the more powerful end of the spectrum, we have s-grammars [7]. In this formalism, the terms over a small set of operators and a finite set of elementary graphs are evaluated in the domain of node-labelled graphs. The operators are defined modulo an auxiliary alphabet, and can merge nodes with identical labels, injectively rename nodes, and clear node names. The membership problem for HRGs and s-grammars require exponential time in general, and HRGs can generate languages for which the associated parsing problem is NP-complete [13]. However, recent work has provided a parser generator [14,15,16] that, for certain subclasses of HRGs, yield a parser that runs in quadratic (and, in the common case, linear) time in the size of its input graph. The graph-parsing tool Grappa is available online [17].

In [18], the authors introduced regular tree foldings, a generative device consisting of a (finite representation of a) regular tree language and a new type of folding operation. The tree language is non-standard in that there is an auxiliary set of symbols $\Delta$, which can be used to mark already labelled nodes, or to label nodes under which sits a single subtree. The folding operation then translates each tree t in the language into a graph by processing t bottom up: every time the evaluation reaches a node v with a label $\alpha \in \Delta$, it merges all nodes in the subtree sitting below v, which carries the mark $\alpha$ into a single node, and clears it from the mark $\alpha$ (see Figure 1). Just like OPDGs, regular tree-foldings are suitable for modelling AMRs, but unlike OPDGs, they can also accommodate cyclic graphs and more varied types of node-sharing. On the down-side, the parsing problem is more difficult: If the relative order among the edges attaching to a node is preserved by the folding, then parsing can be performed in polynomial time in the size of the input graph [19]. If, however, this order is relaxed so that the output graph is considered to be unordered, then the parsing problem is NP-complete [19].

The proof of NP-completeness in [19] reduces the 3-Partition problem into a problem of parsing a regular tree language under two applications of the folding operation. However, the case where only one folding operation is used was left as an open problem. The original construction in [19] does not work, because it requires two fold operations to hide information on how to to partition a multiset into blocks, such that all have three elements and the same sum M. In this paper, we show that the parsing problem for unranked regular tree languages folded once under an order-cancelling fold semantics (see [19] for the contrasting order-preserving case) is solvable in non-uniform polynomial time, i.e., in polynomial time when considering the language as fixed.

Outline

This paper is organised as follows: Section 1 presents the background and motivation for regular tree foldings. Section 2 recalls the necessary parts of tree and graph theory, and fixes the notation. Section 3 presents the folding formalism in more detail. Section 4.1 sets the scene for the tree case by stating and proving a series of helpful lemmas on Vector Addition Systems (VASs). Section 4.2 contains the main result of this work, which is that regular tree languages folded once can be parsed in non-uniform polynomial time, even if the information about the relative order of sibling edges is lost in the folding.

2. Preliminaries

This section recalls relevant formal language theory and fixes notation. Central definitions have been lifted from the introduction of regular tree foldings in [18,19].

The set of non-negative integers is denoted by $\mathbb{N}$. For $i\in \mathbb{N}$, $\left[i\right]=\{1,\dots ,i\}$ and $\left[0\right]=\varnothing$. A multiset $S^{\prime }$ is a set in which elements can have multiple instances.

Graphs: To allow parallel edges, we define our graphs in terms of source and target mappings. An alphabet is a finite nonempty set of symbols. Let $\Sigma$ be an alphabet. A (directed and rooted) graph (note that graphs of this type are usually referred to as rooted multigraphs in the literature, but since they are the only kind that we will be concerned with, we opt to simply refer to them as ‘graphs’) over $\Sigma$ is a tuple $g=(V,E,\mathit{src},\mathit{tar},\mathit{lab},r)$ consisting of: finite sets V and E of nodes and edges, respectively; source and target mappings $\mathit{src}:E\to V$ and $\mathit{tar}:E\to V$ assigning to each edge e its source $\mathit{src}\left(e\right)$ and target $\mathit{tar}\left(e\right)$; a labelling $\mathit{lab}:V\to \Sigma$; and a root node $r\in V$. The set of incoming edges of $u\in V$ is $\mathit{in}\left(u\right)$, and the set of outgoing edges is $\mathit{out}\left(u\right)$. The in-degree of u is $\left|\mathit{in}\left(u\right)\right|$, and the out-degree of u is $\left|\mathit{out}\left(u\right)\right|$. A node with an out-degree 0 is a leaf. The size of the graph g is $\left|g\right|=\left|V\right|+\left|E\right|$. The set of all graphs with node labels in $\Sigma$ is denoted by ${\mathbb{G}}_{\Sigma }$. We write $\mathit{root}\left(g\right)$ for the root node r, and $\mathit{nodes}{\left(g\right)}_{\sigma }$ for the set of nodes in g that are labelled $\sigma \in \Sigma$.

An edge-ordered graph over $\Sigma$ is a pair $(g,<)$, where $g=(V,E,\mathit{src},\mathit{tar},\mathit{lab},r)$ in ${\mathbb{G}}_{\Sigma }$ and < is a binary relation on E that becomes a total order when restricted to any set $\mathit{in}\left(v\right)$ or $\mathit{out}\left(v\right)$, for $v\in V$. From here on, we leave the second component implicit and refer to it as ${<}_g$ when needed. The set of all edge-ordered graphs over $\Sigma$ is denoted by ${\mathbb{G}}_{\Sigma }^{<}$.

A path in the graph $g=(V,E,\mathit{src},\mathit{tar},\mathit{lab},r)$ is a finite and possibly empty sequence $p=e_0{e}_1\cdots e_k$ of edges such that, for each $i\in \left[k\right]$, the target of $e_{i-1}$ is the source of $e_i$. Here, we say that p is a path from $\mathit{src}\left(e_0\right)$ to $\mathit{tar}\left(e_k\right)$. The path p is a cycle if $\mathit{src}\left(e_0\right)=\mathit{tar}\left(e_k\right)$.

Trees: Let $\Sigma$ be an alphabet. An ordered unranked tree over Σ is a tuple $t=((V,E,\mathit{src},\mathit{tar},\mathit{lab},r),<)\in {\mathbb{G}}_{\Sigma }^{<}$, such that (i) t is connected, (ii) r has no incoming edges, and (iii) every node except for r has exactly one incoming edge. We denote the set of all ordered unranked trees over $\Sigma$ by ${\mathrm{T}}_{\Sigma }$.

Let $\sigma \in \Sigma$, $k\in \mathbb{N}$, and $t_1,\dots ,t_k$ be trees over $\Sigma$. Moreover, for each such $t_i=(g_i,{<}_i)$, let $g_i=(V_i,E_i,{\mathit{src}}_i,{\mathit{tar}}_i,{\mathit{lab}}_i,v_i)$, where the node sets $V_i$, $i\in \left[k\right]$, are mutually disjoint, and similarly for the edge sets $E_i$, $i\in \left[k\right]$. The top-concatenation of $t_1,\dots ,t_k$ with $\sigma$, denoted by $\sigma [t_1,\dots ,t_k]$, is the tree obtained by attaching the trees $t_1,\dots ,t_k$ as children underneath a new root node with label $\sigma$.

Top-concatenation is analogously defined for single-rooted graphs, so we may write $\sigma [g_1,\dots ,g_k]$ without risk of confusion. In the case that the graphs are ordered, so are the edges $e_1,\dots ,e_k$ that attach the subgraphs $g_1,\dots ,g_k$; otherwise, they are unordered.

Let X be a set of variables, such that $X\cap \Sigma =\varnothing$. A context is a tree $c\in {\mathrm{T}}_{\left\{x\right\}\cup \Sigma }$, for $x\in X$, such that c contains exactly one occurrence of x, and this occurrence is a leaf. Given such a context and a tree t, we let $c\left[\right[t\left]\right]$ denote the tree obtained from c by replacing the node labelled x with t. Formally, $c\left[\right[t\left]\right]=t$ if $c=x$, and otherwise $c\left[\left[t\right]\right]=\sigma [s_1,\dots ,s_{i-1},s_i\left[\left[t\right]\right],s_{i+1},\dots ,s_n]$, where $c=\sigma [s_1,\dots ,s_n]$ and $s_i\in {\mathrm{T}}_{\left\{x\right\}\cup S}$ is the unique context among $s_1,\dots ,s_n$.

Automata for unranked trees: Unranked tree languages have been studied since the 1960s, most notably as a formal model for the markup language XML [20,21]. In this article, we use Z-automata [22], an extension of step-wise automata [23], to represent such languages. A Z-automaton is a tuple $A=(\Sigma ,Q,R,F)$ consisting of a finite input alphabet $\Sigma$; a finite set Q of states which is disjoint from $\Sigma$; a finite set R of transition rules, each of the form $s\to q$ consisting of a left-hand side $s\in {\mathrm{T}}_{\Sigma \cup Q}$ and a right-hand side $q\in Q$; and a finite set $F\subseteq Q$ of accepting states. Henceforth, we write m for the number of states $\left|Q\right|$.

Let $t\in {\mathrm{T}}_{\Sigma \cup Q}$. A transition rule r of the form $s\to q$ is applicable to t, if t can be written as $t=c\left[\left[\sigma [t_1,\dots ,t_n]\right]\right]$, such that $s=\sigma [t_1,\dots ,t_k]$ for some $k\le n$. If so, then there is a computation step $t{\to }_{A}c\left[\left[q[t_{k+1},\dots ,t_n]\right]\right]$. A computation of A on a tree $t\in \Sigma$ is a sequence of computation steps $t{\to }_A^{*}q$, for some $q\in Q$. The computation is accepting if $q\in F$. A tree $t\in {\mathrm{T}}_{\Sigma }$ is accepted, or recognised, by A if there is an accepting computation of A on t. The language accepted by A, denoted by $\mathcal{L}\left(A\right)$, is the set of all trees in ${\mathrm{T}}_{\Sigma }$ that A accepts.

As shown in [22], Z-automata recognise the same class of languages as unranked tree automata [20]. We use a normal form, in which all transition rules are of the form $\sigma \to r$, $\sigma \left[q\right]\to r$, or $p\left[q\right]\to r$, for $\sigma \in \Sigma$ and $p,q,r\in Q$.

A run of a Z-automaton $A=(\Sigma ,Q,R,F)$ in normal form on a tree t can be seen as assigning states to $\mathit{nodes}\left(t\right)$. For each state $(q,\sigma )$ in $Q\times \Sigma$, there is a regular language $r_{q,\sigma }$ such that in a run, the sequence w of states assigned to the children of a node that has label $\sigma$ and is assigned q must be a string in $r_{q,\sigma }$ [22]. We denote by $\mathit{parikh}(q,\sigma )$ the Parikh image [24] of the language $r_{q,\sigma }$.

3. Regular Tree Foldings

The purpose of the folding operation is to turn an unranked tree t over an alphabet $\Sigma$ into a graph g by merging nodes. The folding is performed by marking nodes with symbols from an auxiliary alphabet $\Delta$, meaning that some nodes will have labels in $\Sigma \times \Delta$, and then, for each $\alpha \in \Delta$ merging all nodes marked with symbols in $\Sigma \times \left\{\alpha \right\}$ into a single node with a label in $\Sigma$. The reason for removing the folding symbol of the node resulting from a merging is to prevent it from being folded together with other nodes later on in the process, which would complicate parsing. By itself, this formalism can only produce output graphs where, at most, $\left|\Delta \right|$ nodes have more than one incoming edge. For this reason, the merging is divided into scopes by allowing for nodes in t that have labels from $\Delta$: a node u in t labelled $\alpha \in \Delta$ is an instruction that all nodes with labels in $\Sigma \times \left\{\alpha \right\}$ below it are to be merged, whereupon the node u itself is to be deleted. The tree is then evaluated bottom-up, so that $\Delta$-labelled nodes lower in the tree have their corresponding operations performed earlier. To keep the result well-defined, the tree language must force nodes with labels in $\Delta$ to have exactly one direct subtree. The combination of a regular unranked tree language over $\Sigma \cup (\Sigma \times \Delta )\cup \Delta$ and a fold operation over $\Delta$ is called a regular tree folding.

The folding operation is illustrated in Figure 1. In the original definition [18], the label of the merged node v is chosen non-deterministically based on the labels of the nodes that went into the merger. However, there is a (less compact) normal form of regular tree foldings, which only merges nodes if they share the same label $(\sigma ,\alpha )\in \Sigma \times \Delta$, and the resulting node in the output graph is then labelled $\sigma$ [19]. This paper is only concerned with the case where there is a single folding symbol, and the normal form allows us to assume that there is a unique $\langle \sigma ,\alpha \rangle \in \Sigma \cup \Delta$ that is allowed by the regular tree language.

Thus, throughout this paper, let $\Sigma$ be an alphabet, let $\sigma \in \Sigma$, and let $\alpha$ be a special symbol not in $\Sigma$. We write $\Gamma$ for the alphabet $\Sigma \cup \{\langle \sigma ,\alpha \rangle ,\alpha \}$.

Definition 1

(The fold operation F). The function $\left[\left[\alpha \right]\right]:{\mathbb{G}}_{\Gamma }\to {\mathbb{G}}_{\Gamma }$ takes a single-rooted input graph $g=(V,E,\mathit{src},\mathit{tar},\mathit{lab},r)\in {\mathbb{G}}_{\Gamma }$ and computes an output graph $h=\left[\right[\alpha \left]\right]\left(g\right)$ by merging the set of nodes $\mathit{nodes}{\left(g\right)}_{\langle \sigma ,\alpha \rangle }$ into a single node u, and assigning u the label σ. If $\mathit{root}\left(g\right)\in \mathit{nodes}{\left(g\right)}_{\langle \sigma ,\alpha \rangle }$, then $\mathit{root}\left(h\right)=u$; otherwise $\mathit{root}\left(h\right)=\mathit{root}\left(g\right)$. The fold operation $F:{\mathrm{T}}_{\Gamma }\to {\mathbb{G}}_{\Gamma }$ is defined for every tree $t=\gamma [t_1,\dots ,t_k]\in {\mathrm{T}}_{\Gamma }$ by $F\left(t\right)=\left[\left[\gamma \right]\right]\left(F\left(t_1\right)\right)$ if $\gamma =\alpha$ (when k is always 1), and $\gamma [F\left(t_1\right),\dots ,F\left(t_k\right)]$ otherwise. It is extended to sets of trees in the expected way: for $L\subseteq {\mathrm{T}}_{\Gamma }$, $F\left(L\right)={\bigcup }_{t\in L}\left\{F\left(t\right)\right\}$.

By combining the fold operation with a regular tree language, we reach our formalism of interest.

Definition 2

(Regular tree folding (with one folding symbol)). A regular tree folding (RTF) over Γ is defined through a Z-automaton A over the same alphabet, such that, for every $t\in \mathcal{L}\left(A\right)$ and every node v in t, it holds that if the label of v is α, then v has exactly one direct subtree. The folded graph language with respect to A is ${\mathcal{L}}_F\left(A\right)=F\left(\mathcal{L}\left(A\right)\right)$.

Example 1.

Figure 2 shows two trees annotated with folding symbols, along with the corresponding graphs they fold into. In the first tree (located on the left in the illustration), the two nodes labelled $\alpha \in \Delta$ (represented as blue squares) appear side-by-side. There is no interaction between their scopes: removing either of these nodes would not affect the outcome of the application of the other. Moving to the second tree (two steps to the right in the same illustration), the lower square node labelled α shadows the scope of the upper one. Had it not been present, then all blue round nodes would have been merged into a single node.

The remainder of this paper is devoted to the membership problem for a fixed RTF represented by a Z-automaton A over $\Gamma$. It asks: given a graph g, is g in ${\mathcal{L}}_F\left(A\right)$? In the special case where folding is only applied once, the problem can be restated as one of combining tree fragments into a single tree in a target language. From here on, $x\notin \Gamma$ is a fixed but arbitrary variable symbol.

A tree fragment is an unordered, unranked tree t with the following properties: (i) The root has exactly one child. (ii) Some leafs may have label x, while all other nodes have labels from $\Gamma$. We call the unique child of the root the prior of t, denoted by $\mathit{prior}\left(t\right)$.

A substitution is an operation that takes a tree or a tree fragment t and ${k=|\mathit{nodes}\left(t\right)}_x|$ sets $T_1,\dots ,T_k$ of tree fragments. It assigns a unique set $T_i$ to each $v_i\in \mathit{nodes}{\left(t\right)}_x$. For each i, the roots of the fragments in $T_i$ are then identified with $v_i$. Finally, $v_i$ is labelled $\langle \sigma ,\alpha \rangle$.

We can thus view any tree as composed from a tree and a number of tree fragments through substitution. Taking this idea further, we note that a single application of a tree folding has the effect of turning the input tree into a set of tree fragments, with all but at most one rooted at the merged node, and some of which have leaves attached to the merged node (see Figure 3). The merged nodes hide how these tree fragments originally fit together, and solving the membership problem is tantamount to recapturing this information. In the following specialisation of the membership problem for the case of single foldings, we denote by $\mathit{order}\left(t\right)$ the set of ordered trees that can be obtained from an unordered tree t by attaching an order to its edges.

Remark 1.

Constructing the tree fragments is trivial in the interesting cases, i.e., the graph will have a single node, which is obviously the merged node, as it has more than one incoming edge. The tree fragments are then obtained by giving each edge incident with the merged node its own copy of that node, as is shown in Figure 3. The other cases, where zero or one node is “merged”, can easily be avoided by rewriting the automaton. That is, we use the states to track and verify a nondeterministic guess whether zero, one, or more than one, node(s) will become merged by a folding operator. For zero, we skip generating the folding operator node (which would do nothing); for one node, we instead generate it with its resulting label and inhibit generating the folding operator node. For two or more, we simply operate the same as the original automaton (but check the guess). Refer to Lemma 4.1 in [19] for a detailed construction easily modified for this case. We begin by dealing with the case of only a single fold, but in Corollary 1, we sketch the straightforward steps needed to reintroduce multiple folds.

Given the above, we can give a slightly different (and, for our, proofs more convenient) statement of the membership problem we are investigating the following.

Definition 3

(Membership problem for one folding). Let A be a fixed but arbitrary Z-automaton over Γ. Given a multiset of unordered tree fragments $\{T_1,\dots ,T_n\}$, is there a sequence of substitutions that uses each tree exactly once, and produces a tree t, such that $\alpha \left[t^{\prime }\right]\in \mathcal{L}\left(A\right)$ for some $t^{\prime }\in \mathit{order}\left(t\right)$?

4. Unfolding Folded Trees

Since the input trees we are working with are unordered (see Definition 3), we extend the behaviour of the Z-automaton A to the unordered case.

Definition 4

(Unordered runs). A run of a Z-automaton $A=(\Sigma ,Q,R,F)$ on an unranked, unordered tree $t=(V,E,\mathit{src},\mathit{tar},\mathit{lab},r)$ is a mapping $\rho :\mathit{nodes}\left(t\right)\to Q$ such that for each node v, the states assigned to the children of the node v, when viewed as a multiset, belongs to $\mathit{parikh}\left(\rho \right(v),\mathit{lab}(v\left)\right)$. For a tree fragment s, a partial run is a run, except that the condition on the children does not apply to the nodes in $\mathit{nodes}{\left(s\right)}_x$.

We can now define the signature of a tree fragment in terms of which partial runs it can realize. The intuition is that, for each x-labelled node and possible assignment of a state to it, we have to find a set of trees to attach that can evaluate to states in the appropriate Parikh image.

Definition 5

(Signature). Let $A=(\Sigma ,Q,R,F)$ be a Z-automaton with $m=\left|Q\right|$, and let t be a tree fragment with ${k=|\mathit{nodes}\left(t\right)}_x|$. The signature of t with respect to A, denoted by $sig\left(t\right)$, is a set of tuples of the form $(q,S)$, where $q\in Q$ and S is a multiset of elements from Q, defined as follows. Let $v_1,\dots ,v_k$ be the nodes in $\mathit{nodes}{\left(t\right)}_x$. Then, $(q,S)$ belongs to the signature iff there is a partial run ρ on t and a partitioning of S into $S_1,\dots ,S_k$, such that $\rho \left(\mathit{prior}\right(t\left)\right)=q$ and, for each i, $S_i\in \mathit{parikh}(\rho \left(v_i\right),\langle \sigma ,\alpha \rangle )$.

The intuition of the above definition is that $(q,S)$ is in the signature of t if t can “accept” $\left|S\right|$ tree fragments whose priors have been assigned the states in S and then “deliver” a state q at its prior.

Given the input set $\{T_1,\dots ,T_n$}, we only need to consider a polynomial number of signatures. Since there are n input trees, we only consider signatures where $\left|S\right|\le n$. The number of such signatures is bounded from above by $m{n}^m$. In other words, the number of possible signatures for all input trees is polynomial. The signature for each input fragment can be computed in polynomial time using a CYK-like dynamic programming algorithm.

Given a set of tree fragments, we compute their signatures, and then reassemble them as in Figure 3, leading to the final theorem.

Theorem 1.

The non-uniform membership problem for tree languages folded once under an order-cancelling semantics is decidable in polynomial time.

Before proving Theorem 1 in Section 4.2, we recall the definition of vector addition systems and prove some properties of these that will turn out to be useful.

4.1. Reassembly Sequences by Vector Addition Systems

To prove Theorem 1, we rely on the signatures to tell us what multisets of states each tree fragment can “consume”, and what state it then “produces”. Finding a way of puzzling the fragments together consistently is a combinatorial problem which we will solve by reducing it to reachability in a restricted form of vector addition systems [25] (the restrictions are key as vector addition systems are in general very powerful [26]). We next present these systems and prove the relevant complexity bound. We then explain the reduction in the proof of Theorem 1.

For vectors u and v, let $(u;v)$ denote their concatenation. Let 𝟘 denote the set of all vectors of zeros, and for all $k\ge 1$, let ${\mathrm{𝟙}}_{\left[k\right]}=\{(z_1;1;z_2)\mid z_1,z_2\in \mathrm{𝟘},|z_1|=k-1\}$, i.e., the unit vectors with a 1 in position k. Let $\mathrm{𝟙}={\cup }_{k\ge 1}{\mathrm{𝟙}}_{\left[k\right]}$, i.e., all unit vectors. We may treat 𝟘 and 𝟙 as vectors when the length is implied by context. For a vector s, we write $s\ge \mathrm{𝟘}$ to indicate that s is pointwise greater than or equal to 𝟘, i.e., that every element of s is nonnegative.

Definition 6.

A Vector Addition System of dimension $k\in \mathbb{N}$ (a k-VAS) is a finite set $V=\{(p,p^{\prime })\mid p\in \{-v\mid v\in {\mathbb{N}}^k\},p^{\prime }\in {\mathbb{N}}^k\}$. We call these the operations. An operation sequence in V is denoted $s_0{\to }_{(p_1,p_1^{\prime })}{s}_1{\to }_{(p_2,p_2^{\prime })}\cdots {\to }_{(p_n,p_n^{\prime })}{s}_n$ for $s_0,\dots ,s_n\in {\mathbb{N}}^k$, and for each $1\le i\le n$

$$1.(p_i,p_i^{\prime })\in V,2.s_{i-1}+p_i\ge \mathrm{𝟘},\mathrm{and},3.s_i=s_{i-1}+p_i+p_i^{\prime }.$$

A vector $s_n$ is reachable from $s_0$ if and only if such an operation sequence exists.

For any $k,l\in \mathbb{N}$, we call a $(k+l)$-VAS V a $(k,l)$-VAS to differentiate the first k elements of the vectors from the rest, writing $((u;v),(u^{\prime };v^{\prime }))\in V$ to signify that $\left|u\right|=|u^{\prime }|=k$ and $\left|v\right|=|v^{\prime }|=l$.

While we define reachability in terms of going from a vector s to a vector t, we are primarily interested in the special case of 𝟘 being reachable, since the numbers will represent tree fragments, all of which must be used.

Definition 7.

A $(k,l)$-VAS V is metered if all $((s;b),(s^{\prime };b^{\prime }))\in V$ have $s,b\in -\mathrm{𝟙}$ and $b^{\prime }\in \mathrm{𝟘}$.

That is, in a metered $(k,l)$-VAS, every operation takes precisely one unit from each of the two parts of the vector, and never adds anything to the second part. We will use the first part, the s vector, to represent a multiset of states, while the second, the b vector, represents a budget. We will informally refer to the vectors accordingly where it makes things more intuitive. This bounded budget then limits the computation in a way similar to a k-bounded Petri net [27].

Definition 8.

For a $(k,l)$-VAS V an operation sequence $(s_0;b_0){\to }_{p_1}\cdots {\to }_{p_n}(s_n;b_n)$ visits a position $i\in \left[k\right]$if at least one vector $s\in \{s_0,\dots ,s_n\}$ is nonzero in position i. The set $I\subseteq \left[k\right]$ is visited if all elements are visited.

Visits only concern the first (state) part of the vector, which makes sense for a metered VAS, as a position in the second part is visited iff it is visited in $b_0$. We will use visits to correspond to uses of states in a run of an automaton over a tree.

We next show that if there exists an operation sequence which visits a set I starting from a vector $v_0$, then there is a short subsequence that does the same.

Lemma 1.

For any metered $(k,l)$-VAS V and operation sequence $v_0{\to }_{p_1}\cdots {\to }_{p_n}{v}_n$ which visits I, there exists an operation sequence $v_0^{\prime }{\to }_{p_1^{\prime }}\cdots {\to }_{p_{\ell }^{\prime }}{v}_{\ell }^{\prime }$ such that: (i) this sequence also visits I; (ii) $v_0^{\prime }=v_0$; (iii) the sequence $p_1^{\prime }\cdots p_{\ell }^{\prime }$ forms a subsequence of $p_1\cdots p_n$; (iv) and $\ell \le k\left|I\right|$.

Proof. 

Let $(s_0;b_0){\to }_{p_1}\cdots {\to }_{p_n}(s_n;b_n)$ be an operation sequence visiting I, for an arbitrary $n\in \mathbb{N}$. Let us abbreviate it as $p_1\cdots p_n$, leaving the vectors implicit. First, consider the singleton case where $I=\left\{i\right\}$, when the following procedure constructs the indicated subsequence. Define $P(p_1\cdots p_n,i)$ recursively as:

• Let j be the smallest index such that, with $(s_0;b_0){\to }_{p_1}\cdots {\to }_{p_j}(s_j;b_j)$, the vector $s_j$ is nonzero at position i.
• If $j=0$, return the empty sequence.
• Letting $p_j=((v_1;v_2),(v_1^{\prime };v_2^{\prime }))$, take $i^{\prime }$ to be the unique (as V is metered) position in $v_1$, which equals $-1$.
• Return $P(p_1\cdots p_{j-1},i^{\prime })·p_j$. That is, the sequence constructed by finding a short visit of $i^{\prime }$ in steps 1 through $j-1$ (one must exist as step $p_j$ subtracted 1 from that position) followed by the operation $p_j$ (which visits i).

Now, $P(p_1\cdots p_n,i)$, starting from $(s_0;b_0)$, forms an operation sequence of a length of at most k, which visits i. The visit to i is straight-forward (the final “$p_j$”), it is of a length of at most k, as each level of the recursion has a distinct i (as the current one is eliminated from the sequence used in the recursive call), and adds one operation. Finally, it is an operation sequence, as each $p_j$ appended in step 4 has its required visit provided by the step immediately prior. The budget part of the vector is unproblematic, as it can only be increased by shortening the sequence.

Generalizing this to an arbitrary set $I\subseteq \left[k\right]$ amounts to an iteration of the above argument. Here, elements of I may compete for the same operations, but this can be handled by having Step 1 in the above procedure pick nondeterministically among the k first such indices j, and then letting the computation fail if two elements of i reuse an operation. In the worst case, each $i\in I$ introduces k new operations to the subsequence, for a total of $k\left|I\right|$ operations. □

Next, we define a relaxed operation sequence, which contains less information, but the existence of which implies the existence of an operation sequence.

Definition 9.

For a metered $(k,l)$-VAS V, a vector $v\in {\mathbb{N}}^{k+l}$, and any $I\subseteq \left[k\right]$, a destructured sequence is a tuple $(v,I,P,S)$ where $P=p_1\cdots p_{k\left|I\right|}\in V^{*}$, where

• $v{\to }_{p_1}\cdots {\to }_{p_{k\left|I\right|}}{v}^{\prime }$ is an operation sequence visiting I;
• S is a multiset over V such that for all $((s;b),(s^{\prime };b^{\prime }))\in S$ the vectors s and $s^{\prime }$ are zero in all positions $z\notin I$;
• $v+{\sum }_{(s,s^{\prime })\in S}(s+s^{\prime })+{\sum }_{(p,p^{\prime })\in P}(p+p^{\prime })=\mathrm{𝟘}.$

The key then becomes that we only need to consider destructured sequences to demonstrate reachability, as they turn out equivalent to full operation sequences in this setting. That is, past a certain length and ensuring a certain subsequence exists, we can disregard the order of operations.

Lemma 2.

For a metered $(k,l)$-VAS V and vector $v\in {\mathbb{N}}^{k+l}$, there exists an operation sequence $v\to \cdots \to \mathrm{𝟘}$ iff there exists a destructured sequence $(v,I,P,S)$.

Proof. 

The “only if” direction: Let $v{\to }_{p_1}\cdots {\to }_{p_n}\mathrm{𝟘}$ be an operation sequence, and take $I\subseteq \left[k\right]$ be the largest set visited by this sequence. Then, apply Lemma 1 to construct P, and let $S=\{p_1,\dots ,p_n\}\setminus P$. Then, $(v,I,P,S)$ is a destructured sequence, fulfilling the requirements of Definition 9: Cond. 1 by Lemma 1, Cond. 2 by construction, and, Cond. 3 as the original sequence reaches 𝟘, so the sum across all its operators, plus the initial vector v, has to be zero.

The “if” direction: given a destructured sequence $(v,I,P,S)$, we can construct an operation sequence which reaches 𝟘 from v. The only thing keeping any particular sequencing of the operations P and S from being an operation sequence from v to 𝟘 is Condition 2 in Definition 6. That is, some position in the first (state) part of the vector may turn negative during the application of an operation. Only the first (state) part going negative can cause problems, as the second (budget) part is used up correctly by all orders, and all orders reach 𝟘 by the definition of a destructured sequence. We now demonstrate how to intersperse the operations in S in P to create a valid operation sequence reaching 𝟘 from v.

This is sketched in Figure 4, and is performed in two phases.

Phase 1: Place cycles at first visit. An ordered submultiset $\{p_1,\dots ,p_n\}\subseteq S$ is a cycle on i if there are vectors $s,t\in {\mathbb{N}}^k$, $s^{\prime },t^{\prime }\in {\mathbb{N}}^l$, such that $(s;s^{\prime }){\to }_{p_1}\cdots {\to }_{p_n}(t;t^{\prime })$ with $s\in {\mathrm{𝟙}}_{\left[i\right]}$, $t\ge s$. If such a cycle exists, split $P=P_1{P}_2$ such that $P_1$ ends with the first visit to i (must exist by the definition of a destructured sequence), and construct a new operation sequence $P_1·p_1\cdots p_n·P_2$, and a new set of operations $S\setminus \{p_1,\dots ,p_n\}$. Take these to be P and S and iterate this procedure until no cycles remain in S. This retains all the properties of the destructured sequence $(v,I,P,S)$, fulfilling all the conditions except the length of P. Specifically, the spliced sequence is an operation sequence because the visit to i allows it to be applied (the budget as usual irrelevant to the reordering), and as $t\ge s$ it cannot cause any later operation to fail.

Phase 2: Order remainder topologically. If S is cycle-free then there is some i such that every $((s;b),(s^{\prime };b^{\prime }))\in S$ has $s^{\prime }$ zero in position i. Otherwise, a visit to i can be made by some operation that requires a visit to $i^{\prime }$, but $i^{\prime }$ can be visited by some operation that requires a visit to $i^{″}$, etc. But no position may repeat in this chain, as that would be a cycle, and there are only finitely many positions, which causes a contradiction. Pick such an i, let $\{p_1,\dots ,p_n\}\subseteq S$ be all such operations p which have $p=((-{\mathrm{𝟙}}_{\left[i\right]};b),(s^{\prime };b^{\prime }))$ (for any b, $s^{\prime }$ and $b^{\prime }$), and construct a new sequence $P·p_1\cdots p_n$ and a new multiset $S\setminus \{p_1,\dots ,p_n\}$. Take these to be P and S, and iterate this procedure until S is empty. This produces an operation sequence, since we maintain the destructured sequence invariant that summing P, S and v produces 𝟘, and as the i picked in each step is not generated by any operation in S, all needed visits must already be in P. After these steps, S is empty and P is an operation sequence reaching 𝟘 from v. □

Theorem 2.

For a metered $(k,l)$-VAS V and vectors $s_0\in {\mathbb{N}}^k$ and $b_0\in {\mathbb{N}}^l$, it is decidable in time $\mathcal{O}\left(\right|V{|}^{k^2+1}(\sum b_0))$ as to whether 𝟘 is reachable from $(s_0;b_0)$.

Proof. 

All relevant tuples $(v,I,P,S)$ can be evaluated to see if they are a destructured sequence, as in Definition 9; if there is one, then by Lemma 2, there exists an operation sequence reaching 𝟘 from v, which is the definition of reachability.

First, for a vector v, define the next smaller vector $v^{\prime }$ as the one formed by decrementing the first nonzero element of v (for example, for $(0,1,2)$ the next vector is $(0,0,2)$, and the next smaller of that is $(0,0,1)$).

To see that the bound holds, regard what tuples we need to test. There are ${\left|V\right|}^{k^2}$ ways of picking P by the bound on its length, and I is entirely determined by P. Try the following for all such P.

Given v, I and P, compute the $v^{\prime }$ reached from v using the operations in P. Then, construct S by searching for a path from $v^{\prime }$ to 𝟘 in the following graph.

• The vector $v^{\prime }$ is a node in the graph.
• If the vector $(s;b)$ is a node in the graph and there exists an operation $p=\left(\right(u;v),$ $(u^{\prime };v^{\prime }))\in V$ such that:
  • $s^{\prime }=s+u+u^{\prime }$, $b^{\prime }=b+v+v^{\prime }$ (vector elements can be negative);
  • The next smaller vector than b is $b^{\prime }$;
  • u and v are zero in all positions not in I.
  then there is a node $(s^{\prime };b^{\prime })$ and an edge from $(s;b)$ to $(s^{\prime };b^{\prime })$ labelled p.

Then, let S be a multiset of operations used (i.e., edges traversed) finding a path from $v^{\prime }$ to 𝟘 in this graph. This procedure is sound and complete.

• An S found this way does make $(v,I,P,S)$ a valid destructured sequence, as by construction $v+{\sum }_{(s,s^{\prime })\in S}(s+s^{\prime })+{\sum }_{(p,p^{\prime })\in P}(p+p^{\prime })=\mathrm{𝟘}$ and S only visits I. All other needed properties derive from an exhaustive enumeration of possible operation sequences P.
• If a destructured sequence does exist, this procedure will find it. Note that the only real pruning happening is requiring the budget to decrease according to the next smaller order. This is necessary to limit the effect l has on the size of the graph, but as S is itself unordered requiring the budget to be used in a certain order is not a real restriction.

Finally, all paths in this graph is of length at most $\sum b_0$ and each node has, at most, $\left|V\right|$ outgoing edges. Combining trying all P with exhaustive search on the graph gives a bound of ${\mathcal{O}\left(\right|V|}^{k^2}\left)\mathcal{O}\right(\left|V\right|(\sum b_0){)=\mathcal{O}(\left|V\right|}^{k^2+1}(\sum b_0))$. □

4.2. Combining the Pieces

With all pieces in place, we can prove that the non-uniform membership problem for regular tree languages folded once is efficiently decidable. We also provide, as a corollary, a slight generalisation of the result, showing that it is enough to assume that there is only one folding symbol, even if it occurs more than once in the trees.

Proof of Theorem 1.

By Definition 3, we have a fixed Z-automaton A and are given an input a graph, which we can decompose into a set of tree fragments $T_1,\dots ,T_n$. Assume that the root node was folded, i.e., the graph has no node with zero incoming edges. This causes no loss of generality: if the graph has a distinguished root node r, give it a parent marked by a new symbol “$\mathit{dummy}$”, and give that node an incoming edge from the folded node. Then, modify A with the necessary additional transitions (such that where it would have previously accepted $\alpha \left[t\right]$, it now accepts $\alpha \left[\langle \sigma ,\alpha \rangle \right[\mathit{dummy}\left[t\right]\left]\right].$) Let $Q=\{q_1,\dots ,q_m\}$ be the states of A, and assume, without loss of generality, that $q_m$ is the only accepting state, and that it occurs on no left-hand-side of a rule in A.

Construct the signatures $\mathrm{sig}\left(T_1\right),\dots ,\mathrm{sig}\left(T_n\right)$ and, from these, construct a metered $(m,n+1)$-VAS V by giving it precisely the following operations: (i) for each $i\in \left[n\right]$ and $(q_j,S)\in \mathrm{sig}\left(T_i\right)$, V has the operation $((-{\mathrm{𝟙}}_{\left[j\right]};-{\mathrm{𝟙}}_{\left[i\right]}),(\overline{S};\mathrm{𝟘}))$, where $\overline{S}$ is S turned into a vector of length m, letting position k be the number of occurrences of $q_k$ in S; and (ii) for each S, such that $S\in \mathit{parikh}(q_m,\langle \sigma ,\alpha \rangle )$ and $\left|S\right|\le n$, V has the operation $((-{\mathrm{𝟙}}_{\left[m\right]};-{\mathrm{𝟙}}_{[n+1]}),(\overline{S};\mathrm{𝟘}))$. Finally, the initial vector is $v=(s;b)$, where $s\in {\mathrm{𝟙}}_{\left[m\right]}$ (with $\left|s\right|=m$) and $b=1\cdots 1$. Intuitively, V simulates reassembling the tree from the fragments. In each step, there is a current vector $(s^{\prime };b^{\prime })$, where $s^{\prime }$ describes the multiset of states which still need to be replaced by a tree fragment, and b describes which tree fragments have already been used. Operations of type (i) attach a tree fragment using one of the present states, where type (ii) initializes the multiset of states to one from which A can accept by going to $q_m$.

Then, 𝟘 is reachable from $(s;b)$ if and only if the tree fragments can be reassembled into a tree accepted by A. By induction on the length of a VAS operation sequence $(s;b)\to \cdots \to \mathrm{𝟘}$, relating each step to a part of some final tree t such that $\alpha \left[t^{\prime }\right]\in \mathcal{L}\left(A\right)$ for some $t^{\prime }\in \mathit{order}\left(t\right)$. That is, the first step (the only operation of type (ii) by construction) establishes the root and a multiset of states the children must produce. The second operation attaches some tree fragment $T_i$ as one of those children by: picking some $(q,S)\in \mathrm{sig}\left(T_i\right)$, removing one q from the state multiset represented, removing the tree fragment itself from the budget, and providing a new set of unaccounted-for children with state multiset S. This maintains the invariant that the part of the tree already constructed can be accepted by A given that the multiset of states currently tracked are provided by the remainder of the procedure. Since 𝟘 is reached no further states are needed, and all tree fragments have been placed.

Finally, we can check whether 𝟘 is reachable from $(s;b)$ by applying Theorem 2, observing that this $(m,n+1)$-VAS has m constant (as A is assumed fixed) and both n and $\left|V\right|$ polynomial. Substituting these into the bound of Theorem 2 yields a polynomial bound. Observe the role Lemma 2 and Theorem 2 play here; in effect, the destructured sequence corresponds to constructing a small tree t, which visits all necessary states without exhibiting any loop. Once this is in place, the remaining tree fragments can be added without keeping record of precisely where they are placed, producing a proper tree. □

We have thus shown that for a fixed regular tree language $\mathcal{L}$, the question of whether a graph g could have been produced by a single application of the order-cancelling fold operation on a tree in $\mathcal{L}$ is solvable in polynomial time. As it turns out, by cutting the graphs up into parts, we can extend this to any number of folding operation applications, as long as they use the same folding symbol.

Corollary 1.

The non-uniform membership problem for tree languages folded using only a single folding symbol under an order-cancelling semantics is decidable in polynomial time.

Proof. 

This generalization of Theorem 1 follows from a helpful separability of graphs using a single folding symbol: if the graph contains no edge that would bisect the graph if removed, then the graph contains at most one folded node, i.e., it has at most one node that is the result of the merging two or more tree nodes.

This must be the case because if there is more than one folded nodes, then the corresponding nodes in the tree which was folded must have been in scope of different instances of the folding operator (or else they would have all been merged into one). Pick (one of) the folding operators which are the furthest from the root of the tree, and consider the edge which connects it to its parent. Removing that edge from the resulting graph will necessarily bisect the graph, because no node below that folding operator can be merged with a node outside of that subtree.

Observe that, by Remark 1, we can, without loss of generality, assume that it is obvious which nodes in the graph are the result of a merge and which are not (i.e., precisely those with more than one incoming edge are merged). We can therefore assume that the automaton does not produce a tree where a folding operator would merge zero or one nodes. The more general case can then be checked through the following steps.

• If the graph contains no merged nodes, it is a tree, and the folding having had no effect. In this case, run the tree automaton on the tree and halt with that result.
• If it contains a single merged node, apply Theorem 1 and halt with that result.
• If there is no edge e which can bisect the graph in a way that separates two merged nodes, reject it. As argued above, it cannot be in the language.
• Pick an edge e which bisects the graph into subgraphs $g_1$ and $g_2$, which both contain merged nodes, letting $g_1$ be the subgraph which has e outgoing and $g_2$ the subgraph that has e incoming. Additionally, pick e such that node that is the source of e has no incoming edge $e^{\prime }$ which would bisect the graph in this way. Observe that such a choice always exists if any bisecting edge does, as one can then pick $e^{\prime }$ instead of e, and repeating this argument cannot lead to a cycle (as removing an edge from a cycle would not bisect the graph). Picking e in this way ensures that the folding operator creating the merged node in $g_2$ is also in $g_2$.
• If the graph is in the language, then the edge e was generated by some rule in the tree automaton. For each state q, attempt to parse $g_1$ and $g_2$ separately as follows:

  (a)

  Add e to $g_1$ letting it go to a new single node labelled $\sigma$, where $\sigma$ is a new symbol not previously in the alphabet. Then, recursively apply this procedure to $g_1$, modifying the automaton with the new rule $\sigma \to q$.

  (b)

  Add e to $g_2$, letting it be outgoing from a new node labelled with a new symbol $\sigma$, add a new (unique) accepting state $q_f$ to the automaton, add the rule $\sigma \left[q\right]\to q_f$. Then, recursively apply this procedure to $g_2$ with this modified automaton.

  (c)

  If 5a and 5b, accept $g_1$ and $g_2$, respectively, and accept the graph g.

• If all states have been tried without accepting, reject.

This procedure is correct, since every graph in the language has to either contain, at most, one application of the folding operator (checked in Steps 1 and 2), or can be bisected by guessing the rule applied (all enumerated by Step 5).

Moreover, the procedure runs in polynomial time. In each recursive call, the polynomial time algorithm of Theorem 1 is applied once, and the number of bisecting edges (across $g_1$ and $g_2$) is decreased by one (as e cannot bisect again). □