| { |
| "paper_id": "U05-1015", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T03:08:37.221521Z" |
| }, |
| "title": "Formal Grammars for Linguistic Treebank Queries", |
| "authors": [ |
| { |
| "first": "Mark", |
| "middle": [], |
| "last": "Dras", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "Centre for Language Technology Macquarie University", |
| "institution": "", |
| "location": {} |
| }, |
| "email": "madras@ics.mq.edu.au" |
| }, |
| { |
| "first": "Steve", |
| "middle": [], |
| "last": "Cassidy", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "Centre for Language Technology Macquarie University", |
| "institution": "", |
| "location": {} |
| }, |
| "email": "steve.cassidy@mq.edu.au" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "There has been recent interest in looking at what is required for a tree query language for linguistic corpora. One approach is to start from existing formal machinery, such as tree grammars and automata, to see what kind of machine is an appropriate underlying one for the query language. The goal of the paper is then to examine what is an appropriate machine for a linguistic tree query language, with a view to future work defining a query language based on it. In this paper we review work relating XPath to regular tree grammars, and as the paper's first contribution show how regular tree grammars can also be a basis for extensions proposed for XPath for common linguistic corpus querying. As the paper's second contribution we demonstrate that, on the other hand, regular tree grammars cannot describe a number of structures of interest; we then show that, instead, a slightly more powerful machine is appropriate, and indicate how linguistic tree query languages might be augmented to include this extra power.", |
| "pdf_parse": { |
| "paper_id": "U05-1015", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "There has been recent interest in looking at what is required for a tree query language for linguistic corpora. One approach is to start from existing formal machinery, such as tree grammars and automata, to see what kind of machine is an appropriate underlying one for the query language. The goal of the paper is then to examine what is an appropriate machine for a linguistic tree query language, with a view to future work defining a query language based on it. In this paper we review work relating XPath to regular tree grammars, and as the paper's first contribution show how regular tree grammars can also be a basis for extensions proposed for XPath for common linguistic corpus querying. As the paper's second contribution we demonstrate that, on the other hand, regular tree grammars cannot describe a number of structures of interest; we then show that, instead, a slightly more powerful machine is appropriate, and indicate how linguistic tree query languages might be augmented to include this extra power.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "There has been recent interest in looking at what is required for a query language for annotated linguistic corpora (Lai and Bird, 2004) . These corpora are used in a range of areas of natural language processing (NLP)-parsing, machine translation, and so on-where they form the basis of training data for statistical methods; and also in linguistics, where they are used to extract examples of particular phenomena for analysis and testing of hypotheses. As noted by Lai and Bird, the prototypical hierarchical linguistic annotation is the syntax tree, and consequently the type of query language that is of interest is a tree query language. One approach to deciding what is required in a tree query language, taken by Lai and Bird (2004) , is to examine and compare a range of existing ones: for example, TGrep2 (Rohde, 2001 ), TIGERSearch (K\u00f6nig and Lezius, 2001 ), or Emu (Cassidy and Harrington, 2001 ). One of their goals is to understand better the formal properties required of query languages. It has been noted in a number of places that treebank querying is in essence a specification of a tree pattern, which matches against the desired trees in the treebank corpus (Abiteboul, 1997) . These tree patterns can be described by existing formal machinery such as tree grammars and automata. An approach complementary to the one mentioned above is thus to examine the extent to which this formal machinery is adequate for describing tree patterns relevant for the sorts of queries of interest in NLP or linguistics, and then to link this to a query language. A reason for being interested in this link between tree query languages and formal machinery is that standard results are available for these latter. For example, an algorithm for recognition exists that is linear in the number of nodes in the tree and the size of the automaton; it is decidable whether the set of matches will be empty; and so on (Comon et al., 1997) . Further, there is the promise of the availability of standard tools and efficient techniques that could be used by a tree query language. This is the case for formal machines over strings (for example, the library of finite-state string transducers of Mohri (1997) ), although not yet for trees. A number of researchers have looked at this complementary approach. One alternative is to design from scratch a tree query language derived from a tree grammar or automaton; this is taken by, for example, Chidlovskii (2000) . Another is to relate an existing query language to a formal machine: Murata et al. (2000) present a taxonomy of XML schema languages using formal language theory. In this paper, we follow the second of these alternatives. Existing work, mostly focussed on XML, has looked only at regular tree grammars and automata for modelling query languages; we examine the extent to which this is the case for linguistic treebanks, and what other machinery might be appropriate for a linguistic tree query language. We argue that while regular tree grammars might be satisfactory for a querying a broad range of phenomena, not all queries over trees representing natural language can be based on a regular tree grammar. This is a structural analogue of the work of Shieber (1985) , which showed that natural language as a string language cannot be generated by a context-free grammar, which corresponds at the tree level to a regular tree grammar. In Section 2 we give the definition of regular tree grammars, along with an approach used to relate them to XPath. In Section 3 we look at extensions to XPath that Cassidy (2003) argues are necessary for linguistic corpus querying, and show that these can be captured by regular tree grammars. In Section 4, however, we present some examples from Dutch from the work of Bresnan et al. (1982) to show that not all desired queries can be represented by regular tree grammars, and examine the question of what strong generative capacity is necessary in a tree grammar for representing natural language. Section 5 gives the definition of a more powerful grammar, the context-free tree grammar, and shows how this can describe queries related to the Dutch instance, along with what properties a query language based on these might have. Finally, Section 6 concludes.", |
| "cite_spans": [ |
| { |
| "start": 116, |
| "end": 136, |
| "text": "(Lai and Bird, 2004)", |
| "ref_id": "BIBREF10" |
| }, |
| { |
| "start": 721, |
| "end": 740, |
| "text": "Lai and Bird (2004)", |
| "ref_id": "BIBREF10" |
| }, |
| { |
| "start": 815, |
| "end": 827, |
| "text": "(Rohde, 2001", |
| "ref_id": "BIBREF14" |
| }, |
| { |
| "start": 843, |
| "end": 866, |
| "text": "(K\u00f6nig and Lezius, 2001", |
| "ref_id": "BIBREF9" |
| }, |
| { |
| "start": 877, |
| "end": 906, |
| "text": "(Cassidy and Harrington, 2001", |
| "ref_id": "BIBREF3" |
| }, |
| { |
| "start": 1179, |
| "end": 1196, |
| "text": "(Abiteboul, 1997)", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 1916, |
| "end": 1936, |
| "text": "(Comon et al., 1997)", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 2191, |
| "end": 2203, |
| "text": "Mohri (1997)", |
| "ref_id": "BIBREF11" |
| }, |
| { |
| "start": 2440, |
| "end": 2458, |
| "text": "Chidlovskii (2000)", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 2530, |
| "end": 2550, |
| "text": "Murata et al. (2000)", |
| "ref_id": "BIBREF12" |
| }, |
| { |
| "start": 3214, |
| "end": 3228, |
| "text": "Shieber (1985)", |
| "ref_id": "BIBREF15" |
| }, |
| { |
| "start": 3561, |
| "end": 3575, |
| "text": "Cassidy (2003)", |
| "ref_id": "BIBREF4" |
| }, |
| { |
| "start": 3767, |
| "end": 3788, |
| "text": "Bresnan et al. (1982)", |
| "ref_id": "BIBREF1" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Regular tree grammars (RTGs) are in essence those trees whose paths are defined by regular grammars. Comon et al. (1997) provide an introduction to necessary concepts in tree grammars, along with well known results such as that the string languages yielded by RTG trees are the context-free languages. In their treatment they divide tree representations into two types: those for ranked trees (that is, where each symbol has a fixed number of children, with this number constituting the rank of the symbol), and those for unranked trees. XML schema languages typically use unranked trees, so we adopt, slightly modified, the definitions of these from Br\u00fcggemann-Klein et al. 2001and Murata et al. (2000) . A regular tree grammar is a 4-tuple G = (\u03a3, N, P, S) such that", |
| "cite_spans": [ |
| { |
| "start": 101, |
| "end": 120, |
| "text": "Comon et al. (1997)", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 683, |
| "end": 703, |
| "text": "Murata et al. (2000)", |
| "ref_id": "BIBREF12" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u2022 \u03a3 is a finite set of terminal symbols;", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u2022 N is a finite set of nonterminal symbols;", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u2022 P is a finite set of productions of the form X \u2192 a(R), where X \u2208 N , a \u2208 \u03a3, and R is a regular expression over N \u222a\u03a3; and", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u2022 S is the start symbol, S \u2208 N .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Derivation \u21d2 (with transitive closure * \u21d2) is defined in the usual way, with nonterminals symbols rewritten by means of production rules, starting from the start symbol S. is the conventional null terminal symbol. The set of trees generated by G is L(G).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Example 2.1 Let G 1 = (\u03a3, N, P, S) such that \u03a3 = {a, b}, N = {S, X}, and P = {S \u2192 a(aSa), S \u2192 a(bXb), X \u2192 b(bXb), X \u2192 b}. A sample derivation is given in Figure 1 . L(G 1 ) is thus the set of ternary-branching trees over the symbols a and b, where all nodes to a certain depth D are a nodes, and all below are b nodes. To relate this to a query language, we now review the approach presented in Wood (2003) to relate these regular tree grammars to XPath (XPath, 1999 The work of Wood himself is on the fragment XP {[], * ,//} and the question of whether the containment problem-whether one query is subsumed by another-under a Document Type Definition can be decided in the complexity class ptime. To demonstrate that this is the case he conceives of XPath queries as tree patterns (Abiteboul, 1997; Deutsch et al., 1999) , which can be described by regular tree grammars. For example, the XPath query of Example 2.2 could be pictured as the tree pattern on the right in Figure 2 , where the dotted line indicates non-immediate dominance. An RTG then describes all trees matching this tree pattern. In order to define this RTG, Wood defines some shorthand notation, which we will also adopt. For an alphabet \u03a3 = {a 1 , . . . , a k }, we write n \u2192 \u03a3(r) for the set of productions {n \u2192 a 1 (r), . . . , n \u2192 a k (r)}. In order to generate an arbitrary tree over \u03a3, we define a nonterminal n \u03a3 by the shorthand production n \u03a3 \u2192 \u03a3((n \u03a3 ) * ).", |
| "cite_spans": [ |
| { |
| "start": 395, |
| "end": 406, |
| "text": "Wood (2003)", |
| "ref_id": "BIBREF16" |
| }, |
| { |
| "start": 454, |
| "end": 466, |
| "text": "(XPath, 1999", |
| "ref_id": null |
| }, |
| { |
| "start": 782, |
| "end": 799, |
| "text": "(Abiteboul, 1997;", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 800, |
| "end": 821, |
| "text": "Deutsch et al., 1999)", |
| "ref_id": "BIBREF6" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 154, |
| "end": 162, |
| "text": "Figure 1", |
| "ref_id": "FIGREF0" |
| }, |
| { |
| "start": 971, |
| "end": 979, |
| "text": "Figure 2", |
| "ref_id": "FIGREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Example 2.3 For the query Q = a/b over alphabet \u03a3, the productions for the corresponding RTG are", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "n a \u2192 a((n \u03a3 ) * n b (n \u03a3 ) * ) n b \u2192 b((n \u03a3 ) * )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "An additional shorthand is to compress the ordering of siblings implicit in RTGs. Each permutation of children at a node would require a separate production, so as shorthand the & symbol is used: a&b represents ab and ba (a, b \u2208 \u03a3).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Example 2.4 The productions from the query", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "a[b][c] are n a \u2192 a((n \u03a3 ) * & n b & (n \u03a3 ) * & n c & (n \u03a3 ) * ) n b \u2192 b((n \u03a3 ) * ) n c \u2192 c((n \u03a3 ) * )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Example 2.5 The productions for the query a//b are", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "n a \u2192 a((n \u03a3 ) * n b (n \u03a3 ) * ) n b \u2192 b((n \u03a3 ) * ) n b \u2192 \u03a3((n \u03a3 ) * n b (n \u03a3 ) * )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Wood then defines the following procedure for constructing an RTG G from a query Q, given an alphabet \u03a3 = {a 1 , . . . , a k , * } and Q in XP {[], * ,//} . First, each node in Q is numbered uniquely, with the root node numbered 1. Then G is given by (\u03a3, N, P, n 1 ), where N = {n 1 , . . . , n m , n \u03a3 }, and P is constructed inductively as follows.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "1. If node i in Q is a leaf, then P includes", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "n i \u2192 a j ((n \u03a3 ) * ) if i has label a j \u2208 \u03a3, or n i \u2192 \u03a3((n \u03a3 ) * ) if i has label *.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "2. If node i in Q has child nodes j 1 , . . . , j m , then", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "P includes n i \u2192 a l ((n \u03a3 ) * & n j 1 & (n \u03a3 ) * & . . . & (n \u03a3 ) * & n j m & (n \u03a3 ) * ) if i has label a l \u2208 \u03a3, or n i \u2192 \u03a3((n \u03a3 ) * & n j 1 & (n \u03a3 ) * & . . . & (n \u03a3 ) * & n j m & (n \u03a3 ) * ) if i has label *.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "3. If node i in Q is connected to its parent by a descendent edge, then P includes", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "n i \u2192 \u03a3((n \u03a3 ) * n i (n \u03a3 ) * )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "3 XPath Extensions and RTGs Cassidy (2003) presented some extensions to XPath, based on the requirements of typical linguistic queries. An example is that of finding matches for a given syllable structure: \"Find sequences of any number of consonant phonemes followed by a single vowel following by any number of consonants\". This would require a regular expression (C+VC+) over the /following axis. Under the current definition of XPath, it is not possible to specify regular expressions over axes; nor is it possible to specify more complex definitions of where conditions on nodes should be applied. Cassidy consequently specifies an extension that allows this, which has the following components:", |
| "cite_spans": [ |
| { |
| "start": 28, |
| "end": 42, |
| "text": "Cassidy (2003)", |
| "ref_id": "BIBREF4" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "axis This is as for the axes in the standard XPath definition.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "step This determines how many steps should be taken along the axis, and takes the form of a list of positive integers or a special value inf. A path length is allowed if it matches one of the integers in the list; any path length is allowed if only the value inf is given; path lengths greater than the highest integer are allowed if the list contains both integers and the value inf. For example, [2, 3, 4] allows paths only of lengths 2, 3 or 4; [1, 10, inf] allows paths of length 1 or of length greater than 10.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "condition This is a general boolean condition on nodes in the same sense as XPath.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "where This specifies where on the path the condition must hold, via a list of positive integers or the special values inf or end. An integer in the list means that the condition is applied to that node; inf means that the condition must hold for all nodes in the path; end means that the condition applies to the final node on the path. For example, the list [1, 2, end] would find paths where the condition was satisfied by the first, second and last nodes on the path. A proposed syntax for this, in keeping with the XPath syntax, would be /axis{step}::condition::{where} The step and where components would default to their XPath values (1 and end respectively).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Example 3.1 Cassidy gives an example for the C+VC+ query which uses the /following axis. An analogous example using the axes already presented in Section 2 would be one to match trees with a chain of VP nodes followed immediately below by a chain of NP nodes, such as the one in The question is then, Can this extension be represented by RTGs? The intuition is that it can-the essence of this aspect of the extension is to allow regular expressions over paths, which is also the essence of RTGs. We demonstrate this below by giving a construction of an RTG for each extended XPath query. As with the construction in Section 2, we will look at just a restricted subset of this XPath extension: axis /child and /descendent (which is in fact just an infinite /child); step as defined above; condition only labels on nodes, or *; and where as above. We call this XP-ext.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Example 3.2 The query in Example 3.1 would be represented by the RTG ({VP, NP, * }, {n S , n V , n N }, P, n S }), where P is the set of productions", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "n S \u2192 \u03a3((n \u03a3 ) * n V (n \u03a3 ) * ) n V \u2192 VP((n \u03a3 ) * n V (n \u03a3 ) * ) n V \u2192 VP((n \u03a3 ) * n N (n \u03a3 ) * ) n N \u2192 NP((n \u03a3 ) * ) n N \u2192 NP((n \u03a3 ) * n N (n \u03a3 ) * )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "To derive an RTG corresponding to a query in XP-ext, we identify the corresponding tree pattern(s). First, to allow regular expressions over paths in tree patterns, we make a further notational extension, either adding the symbol c next to the non-immediate dominance link in the tree pattern, to indicate that the condition holds over the nonimmediate dominance link, or the symbol * if it does not. Now, we need to look at two separate cases. The first case is the general one: in aiming only to match sets of trees by tree patterns, only one tree pattern is generally necessary, regardless of the number of elements specified in the step and where components. This is because although one pattern tree might be expected for each step value, in fact one describing the smallest step suffices, as it subsumes any other. For example, in the query /child{2,4}::S::{2,4}, any tree which matches the appropriate pattern tree of height 4 will match the pattern tree of height 2. Note that these different steps and wheres are differentiated with respect to the XPath return values; however, that is beyond the scope of this paper, which concerns itself only with trees matched. The second case deals with the specific case of where value end; the subsumption relationship does not hold here. For example, consider the query /child{2,4}::S::{end} over trees consisting of a single path. There will be trees where the end of the path (step) of length 2 (matching the label S) do not have an S node at the end of the path of length 4, and vice versa; that is, there is no subset relation between the sets of trees specified for steps of lengths 2 and 4. We define these two cases below. In these definitions, we take axis /child and condition (i.e. node label) c.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Case 1 For query Q with step [i 1 , . . . , i n , inf] (i 1 < . . . < i n ), and where [j 1 , . . . , j m , inf] (j 1 < . . . < j m < inf),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "we construct a tree pattern of height i p , where i p is the smallest element of [i 1 , . . . , i n , inf] with label c for each node j p (p < m, j p < i p ). If i p is inf, we label the non-immediate dominance edge c if where contains inf, * otherwise.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Regular Tree Grammars", |
| "sec_num": "2" |
| }, |
| { |
| "text": "2 For query Q with step [i 1 , . . . , i n , inf] (i 1 < . . . < i n ), and where [end], we construct one tree pattern for each element of step, with the last node in each tree pattern labelled c, and any non-immediate dominance edge labelled * . Figure 4 . Our construction for an RTG is then as for the construction in Section 2, but with part 3 replaced by with 3':", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 247, |
| "end": 255, |
| "text": "Figure 4", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Case", |
| "sec_num": null |
| }, |
| { |
| "text": "3' If node i in Q is connected to its parent by a non-immediate dominance edge labelled with a \u2208 \u03a3, then P includes", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Case", |
| "sec_num": null |
| }, |
| { |
| "text": "n i \u2192 a((n \u03a3 ) * n i (n \u03a3 ) * ) or if unlabelled, then P includes n i \u2192 \u03a3((n \u03a3 ) * n i (n \u03a3 ) * )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Case", |
| "sec_num": null |
| }, |
| { |
| "text": "4 Non-Regular Queries", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Case", |
| "sec_num": null |
| }, |
| { |
| "text": "However, some queries that are of interest to (computational) linguists are not able to be expressed by RTGs. There was much discussion in the mid-to late-twentieth century regarding whether natural languages could be described by context-free (string) grammars (CFGs). A fairly common belief was that they could not be, accompanied by attempts to prove this; Pullum and Gazdar (1982) refuted these earlier arguments, and it was not definitively shown that natural language as a string language was not context-free until the work of Shieber on Swiss German (Shieber, 1985) . Bresnan et al. (1982) , in addition, made an argument based on syntactic structure, using the example of Dutch.", |
| "cite_spans": [ |
| { |
| "start": 360, |
| "end": 384, |
| "text": "Pullum and Gazdar (1982)", |
| "ref_id": "BIBREF13" |
| }, |
| { |
| "start": 558, |
| "end": 573, |
| "text": "(Shieber, 1985)", |
| "ref_id": "BIBREF15" |
| }, |
| { |
| "start": 576, |
| "end": 597, |
| "text": "Bresnan et al. (1982)", |
| "ref_id": "BIBREF1" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Case", |
| "sec_num": null |
| }, |
| { |
| "text": "We represent their argument, where they show that an RTG cannot describe this kind of structure-which obviously has some linguistic interest-and hence neither can any tree query language based on it. We then consider what formal tree machine is minimally needed for describing natural language. Cross-serial dependencies occur when dependencies in a sentence are interleaved with each other, such that in a string a 1 a 2 . . .a n b 1 b 2 . . .b n there are dependencies between elements a i and b i (i \u2208 {1 . . . n}). A well known example from Dutch, given in Bresnan et al. (1982) , is in Figure 5 . Pullum and Gazdar (1982) showed that it was possible to describe the string language using a CFG, but noted that the associated structure would not necessarily be useful. Bresnan et al. (1982) then comprehensively investigated what structures would be appropriate on linguistic grounds. One proposal they considered was for a flat structure of NPs, with right-branching VPs, as in the leftmost tree of Figure 5 , with evidence for the right-branching VPs coming from possibilities of conjunctions in Dutch. However, they noted that the sequence of NPs has more constituent structure than indicated in the leftmost tree of Figure 5 , and conclude that the structure in the centre of Figure 5 is the one that is consistent with the data. They note that this proposed structure should be uncontroversial, as it embodies only predicateargument relations, rather than any aspects of syntax whose representations may be more open to question. They use a pumping lemma for regular tree languages to demonstrate that sets of these sorts of trees from Figures 5 cannot be generated by RTGs. Comon et al. (1997) give a more precise definition, but broadly, for any tree T of height greater than some constant k in a tree language L, there is a nontrivial segment of T that can be 'pumped' in a manner analogous to in the pumping lemma for regular string grammars; and any tree formed from T with an arbitrary number of these segments inserted appropriately will also be in L. In the case of the centre tree of Figure 5 , there is no segment of the tree that can be chosen to be pumped that will maintain equal numbers of NPs and Vs (that is, specifying the same tree language). Roughly speaking, there cannot be counting or matching of numbers of internal symbols in tree patterns. We note here that there is an additional possibility that they do not discuss that is also consistent with the data, differing only in the placement of the subtree headed with the V ; this is the rightmost tree in Figure 5 . The same pumping lemma shows that the set of these trees also cannot be generated by an RTG.", |
| "cite_spans": [ |
| { |
| "start": 561, |
| "end": 582, |
| "text": "Bresnan et al. (1982)", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 602, |
| "end": 626, |
| "text": "Pullum and Gazdar (1982)", |
| "ref_id": "BIBREF13" |
| }, |
| { |
| "start": 773, |
| "end": 794, |
| "text": "Bresnan et al. (1982)", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 1678, |
| "end": 1703, |
| "text": "RTGs. Comon et al. (1997)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 591, |
| "end": 599, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 1004, |
| "end": 1012, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 1224, |
| "end": 1232, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 1284, |
| "end": 1292, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 2102, |
| "end": 2110, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 2588, |
| "end": 2596, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Case", |
| "sec_num": null |
| }, |
| { |
| "text": "What, then, can generate these sets of trees? One possibility is a context-free tree grammar (CFTG). The basic idea of these is that, whereas trees generated by RTGs have regular paths, CTFGs have context-free paths. CFTGs were introduced in Rounds (1970). We do not have space for a full formal presentation of them, and we would also note that unlike the RTGs defined above they are defined over ranked trees. However, here is a brief definition, along with an example. A context-free tree grammar G is a 4-tuple (F, \u03a6, P, K 0 ) where F is a finite ranked alphabet; \u03a6 = {K 0 , K 1 , . . . , K n } is a finite ranked alphabet of nonterminals; P is the set of production rules, a finite set of pairs", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "(K i (x 1 , . . . , x m ), t x )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": ", where i = 0, . . . , n, K i \u2208 F, x i are variables, and t x is a tree over F , \u03a6 and variables x i ; and K 0 is the initial nonterminal. An application of a production rule to a tree T involves choosing a nonterminal K i with m children, taking a rule with lefthand side K i (x 1 , . . . , x m ), identifying the m subtrees of K i in T with the variables x 1 , . . . , x m , and replacing the chosen subtree of T rooted in K i with the righthand side of the rule along with appropriately substituted variables x 1 , . . . , x m . No CFTG is possible for the leftmost tree of Figure 5 , as symbols are ranked, and that tree would require an infinite number of ranked symbols with label S to describe the unbounded number of children NP. A CFTG to describe the centre tree of Figure 5 would be G = (F, \u03a6, P, K 0 ), where F = {S, NP, VP, V'}, \u03a6 = {K 0 , K 1 }, and P is the set of productions given in Figure 6 . A CFTG to describe the rightmost tree of Figure 5 would be G = (F, \u03a6, P , K 0 ), where", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 577, |
| "end": 585, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 901, |
| "end": 909, |
| "text": "Figure 6", |
| "ref_id": null |
| }, |
| { |
| "start": 953, |
| "end": 961, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "K0 \u2192 S NP K1 NP VP NP V' V1 V' V2 V' V3 K1 x1 x2 x3 \u2192 K1 x1 VP NP x2 V' V x3 K1 x1 x2 x3 \u2192 VP x1 x2", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "x3 Figure 6 : CFTG for cross-serial option 2", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 3, |
| "end": 11, |
| "text": "Figure 6", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "K0 \u2192 S NP VP K1 V' V K1 x1 \u2192 VP NP K1 V' V x1 K1 x1 \u2192 VP NP VP V' V x1", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "Figure 7: CFTG for cross-serial option 3", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "F and \u03a6 are as for G above, and P is the set of productions in Figure 7 . In essence, CFTGs allow 'counting' throughout a tree-in the examples above, the counts of NPs and Vs match-in the same way as CFGs allow counting in a string. Thus CFTGs might be a suitable backbone for a tree query language. However, they are not computationally very attractive. Just as the string languages yielded by RTGs are the context-free languages, the string languages yielded by CFTGs are the indexed languages, which include exponentially increasing languages such as {a 2 n | n \u2265 1} that are not a feature of any human language. However, the sets of productions P and P are actually quite different. It is straightforward to demonstrate that those in P are in fact spinal-formed under the definition of Fujiyoshi and Kasai (2000) . In essence, a spinal-formed CFTG disallows duplication of counts along different paths (as in the duplicate counts of NPs and Vs in separate subtrees of the centre tree of Figure 5 ). Spinal-formed CFTGs form a proper subset of CFTGs with much restricted power; interestingly, their string languages have been proved by Fujiyoshi and Kasai (2000) to be the class of mildly context-sensitive languages, and recent work (Fujiyoshi and Kawaharada, 2005) This rightmost tree of Figure 5 , then, establishes that a language to query trees representing the syntax of natural language requires an underlying tree machine beyond RTGs, but not necessarily beyond the power of spinal-formed CFTGs. An additional result of Fujiyoshi and Kasai (2000) is the definition of a Linear Pushdown Tree Automaton (L-PDTA) that recognises exactly the class of trees generated by spinalformed CFTGs. These are similar to the automata that recognise the tree sets of RTGs, but have a non-duplicable stack in operation as the automaton walks a path of a tree; that is, the stack can only be passed along a single branch of the tree. This suggests that a similar mechanism might be appropriate for a tree query language that would allow limited counting. Using the notation of Section 3, we might have a query to find trees with (not necessarily balanced) NPs and Vs with the structure of the rightmost tree of where X is a variable containing the count of nodes matched by the particular components of the query, and |Y | represents the number of steps actually matched for list of steps Y . To restrict this to match only those trees describable by spinal-formed CFTGs, passing counts down through predicate expressions, which would in effect permit stack duplication, is disallowed (e.g. VP[/child::NP]). However, this is just an indication of the form that an XPath-like query language based on a spinal-formed CFTG might take, and is intended only to be the starting point for future work.", |
| "cite_spans": [ |
| { |
| "start": 790, |
| "end": 816, |
| "text": "Fujiyoshi and Kasai (2000)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 1139, |
| "end": 1165, |
| "text": "Fujiyoshi and Kasai (2000)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 1237, |
| "end": 1269, |
| "text": "(Fujiyoshi and Kawaharada, 2005)", |
| "ref_id": "BIBREF8" |
| }, |
| { |
| "start": 1531, |
| "end": 1557, |
| "text": "Fujiyoshi and Kasai (2000)", |
| "ref_id": "BIBREF7" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 63, |
| "end": 71, |
| "text": "Figure 7", |
| "ref_id": null |
| }, |
| { |
| "start": 991, |
| "end": 999, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| }, |
| { |
| "start": 1293, |
| "end": 1301, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": ". . . V' V 1 V' V 2 V' V 3 . . . S NP 1 VP NP 2 VP NP 3 . . . V' V 1 V' V 2 V' V 3 . . . S NP 1 VP NP 2 VP NP 3 . . . V' V 1 V' V 2 V' V 3 . . .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Context-Free Tree Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "The aim of this paper has been to examine what formal machinery is necessary for linguistic tree query languages. Existing tree query languages are typically related to regular tree grammars, although these query languages are almost exclusively for nonlinguistic XML documents. The first contribution of the paper has been to show that regular tree grammars can be used as the basis for a range of proposed extensions to XPath motivated by linguistic considerations, for very typical sorts of queries such as those representing a search for a regular expression over axes. The paper's second contribution has been to demonstrate that regular tree grammars cannot, however, be a basis for some queries of linguistic interest. We have shown that machines with at least the power of spinal-formed context-free tree grammars, with their limited ability to count, can describe those constructions that are beyond RTGs, and made initial suggestions on how this ability to count could be incorporated into a query language. There is much scope for future work in this direction. To deal with XPath return values we are interested in transducers based on (subtypes of) context-free tree grammars which have not yet been defined; many of the properties of the formal mechanisms remain to be investigated; and, most relevant to this paper, it is an open question as to how precisely a query language can be defined based on this mechanism.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "6" |
| }, |
| { |
| "text": "The topmost NP in the tree, under the S, is not matched by the query.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "Querying Semi-Structured Data", |
| "authors": [ |
| { |
| "first": "Serge", |
| "middle": [], |
| "last": "Abiteboul", |
| "suffix": "" |
| } |
| ], |
| "year": 1997, |
| "venue": "Database Theory-ICDT'97", |
| "volume": "", |
| "issue": "", |
| "pages": "1--18", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Serge Abiteboul. 1997. Querying Semi- Structured Data. In Foto Afrati and Phokion Kolaitis, editors, Database Theory-ICDT'97, pages 1-18. Springer-Verlag.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "Cross-serial Dependencies in Dutch", |
| "authors": [ |
| { |
| "first": "Joan", |
| "middle": [], |
| "last": "Bresnan", |
| "suffix": "" |
| }, |
| { |
| "first": "Ronald", |
| "middle": [], |
| "last": "Kaplan", |
| "suffix": "" |
| }, |
| { |
| "first": "Stanley", |
| "middle": [], |
| "last": "Peters", |
| "suffix": "" |
| }, |
| { |
| "first": "Annie", |
| "middle": [], |
| "last": "Zaenen", |
| "suffix": "" |
| } |
| ], |
| "year": 1982, |
| "venue": "Linguistic Inquiry", |
| "volume": "", |
| "issue": "4", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Joan Bresnan, Ronald Kaplan, Stanley Peters, and Annie Zaenen. 1982. Cross-serial Dependen- cies in Dutch. Linguistic Inquiry, 13(4).", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "Regular tree and regular hedge languages over unranked alphabets", |
| "authors": [ |
| { |
| "first": "Anne", |
| "middle": [], |
| "last": "Br\u00fcggemann-Klein", |
| "suffix": "" |
| }, |
| { |
| "first": "Makoto", |
| "middle": [], |
| "last": "Murata", |
| "suffix": "" |
| }, |
| { |
| "first": "Derick", |
| "middle": [], |
| "last": "Wood", |
| "suffix": "" |
| } |
| ], |
| "year": 2001, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Anne Br\u00fcggemann-Klein, Makoto Murata, and Derick Wood. 2001. Regular tree and regular hedge languages over unranked alphabets. Tech- nical Report HKUST-TCSC-2001-05, Hong Kong University of Science and Technology.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Multi-level annotation in the Emu speech database management system", |
| "authors": [ |
| { |
| "first": "Steve", |
| "middle": [], |
| "last": "Cassidy", |
| "suffix": "" |
| }, |
| { |
| "first": "Jonathon", |
| "middle": [], |
| "last": "Harrington", |
| "suffix": "" |
| } |
| ], |
| "year": 2001, |
| "venue": "Speech Communication", |
| "volume": "33", |
| "issue": "", |
| "pages": "61--77", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Steve Cassidy and Jonathon Harrington. 2001. Multi-level annotation in the Emu speech database management system. Speech Commu- nication, 33(1-2):61-77.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Generalizing XPath for directed graphs", |
| "authors": [ |
| { |
| "first": "Steve", |
| "middle": [], |
| "last": "Cassidy", |
| "suffix": "" |
| } |
| ], |
| "year": 2003, |
| "venue": "Proceedings of Extreme Markup Languages", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Steve Cassidy. 2003. Generalizing XPath for di- rected graphs. In Proceedings of Extreme Markup Languages 2003.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "Using Regular Tree Automata as XML schemas", |
| "authors": [ |
| { |
| "first": "Boris", |
| "middle": [], |
| "last": "Chidlovskii", |
| "suffix": "" |
| }, |
| { |
| "first": "M", |
| "middle": [], |
| "last": "; H. Comon", |
| "suffix": "" |
| }, |
| { |
| "first": "R", |
| "middle": [], |
| "last": "Dauchet", |
| "suffix": "" |
| }, |
| { |
| "first": "F", |
| "middle": [], |
| "last": "Gilleron", |
| "suffix": "" |
| }, |
| { |
| "first": "D", |
| "middle": [], |
| "last": "Jacquemard", |
| "suffix": "" |
| }, |
| { |
| "first": "S", |
| "middle": [], |
| "last": "Lugiez", |
| "suffix": "" |
| }, |
| { |
| "first": "M", |
| "middle": [], |
| "last": "Tison", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Tommasi", |
| "suffix": "" |
| } |
| ], |
| "year": 1997, |
| "venue": "Tree Automata Techniques and Applications. Available on", |
| "volume": "", |
| "issue": "", |
| "pages": "89--104", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Boris Chidlovskii. 2000. Using Regular Tree Au- tomata as XML schemas. In Proceedings of IEEE Advances in Digital Libraries, pages 89-104. H. Comon, M. Dauchet, R. Gilleron, F. Jacquemard, D. Lugiez, S. Tison, and M. Tommasi. 1997. Tree Automata Tech- niques and Applications. Available on: http://www.grappa.univ-lille3.fr/tata. Release October 1st 2002.", |
| "links": null |
| }, |
| "BIBREF6": { |
| "ref_id": "b6", |
| "title": "A Query Language for XML", |
| "authors": [ |
| { |
| "first": "Alin", |
| "middle": [], |
| "last": "Deutsch", |
| "suffix": "" |
| }, |
| { |
| "first": "Mary", |
| "middle": [], |
| "last": "Fernandez", |
| "suffix": "" |
| }, |
| { |
| "first": "Daniela", |
| "middle": [], |
| "last": "Florescu", |
| "suffix": "" |
| }, |
| { |
| "first": "Alon", |
| "middle": [], |
| "last": "Levy", |
| "suffix": "" |
| }, |
| { |
| "first": "Dan", |
| "middle": [], |
| "last": "Suciu", |
| "suffix": "" |
| } |
| ], |
| "year": 1999, |
| "venue": "Proceedings of the 8th International World Wide Web Conference", |
| "volume": "", |
| "issue": "", |
| "pages": "77--91", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Alin Deutsch, Mary Fernandez, Daniela Florescu, Alon Levy, and Dan Suciu. 1999. A Query Lan- guage for XML. In Proceedings of the 8th Inter- national World Wide Web Conference, pages 77- 91.", |
| "links": null |
| }, |
| "BIBREF7": { |
| "ref_id": "b7", |
| "title": "Spinal-Formed Context-Free Tree Grammars. Theory of Computing Systems", |
| "authors": [ |
| { |
| "first": "A", |
| "middle": [], |
| "last": "Fujiyoshi", |
| "suffix": "" |
| }, |
| { |
| "first": "T", |
| "middle": [], |
| "last": "Kasai", |
| "suffix": "" |
| } |
| ], |
| "year": 2000, |
| "venue": "", |
| "volume": "33", |
| "issue": "", |
| "pages": "59--83", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "A. Fujiyoshi and T. Kasai. 2000. Spinal-Formed Context-Free Tree Grammars. Theory of Com- puting Systems, 33:59-83.", |
| "links": null |
| }, |
| "BIBREF8": { |
| "ref_id": "b8", |
| "title": "Deterministic Recognition of Trees Accepted by a Linear Pushdown Tree Automaton", |
| "authors": [ |
| { |
| "first": "A", |
| "middle": [], |
| "last": "Fujiyoshi", |
| "suffix": "" |
| }, |
| { |
| "first": "I", |
| "middle": [], |
| "last": "Kawaharada", |
| "suffix": "" |
| } |
| ], |
| "year": 2005, |
| "venue": "Proceedings of the Tenth International Conference on Implementation and Application of Automata", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "A. Fujiyoshi and I. Kawaharada. 2005. Deter- ministic Recognition of Trees Accepted by a Lin- ear Pushdown Tree Automaton. In Proceedings of the Tenth International Conference on Imple- mentation and Application of Automata.", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "The TIGER language-a description language for syntax graphs. Part 1: User's guidelines", |
| "authors": [ |
| { |
| "first": "Esther", |
| "middle": [], |
| "last": "K\u00f6nig", |
| "suffix": "" |
| }, |
| { |
| "first": "Wolfgang", |
| "middle": [], |
| "last": "Lezius", |
| "suffix": "" |
| } |
| ], |
| "year": 2001, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Esther K\u00f6nig and Wolfgang Lezius. 2001. The TIGER language-a description language for syntax graphs. Part 1: User's guidelines. Tech- nical report, IMS, University of Stuttgart.", |
| "links": null |
| }, |
| "BIBREF10": { |
| "ref_id": "b10", |
| "title": "Querying and Updating Treebanks: A Critical Survey and Requirements Analysis", |
| "authors": [ |
| { |
| "first": "Catherine", |
| "middle": [], |
| "last": "Lai", |
| "suffix": "" |
| }, |
| { |
| "first": "Steven", |
| "middle": [], |
| "last": "Bird", |
| "suffix": "" |
| } |
| ], |
| "year": 2004, |
| "venue": "Proceedings of the Australasian Language Technology Workshop", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Catherine Lai and Steven Bird. 2004. Query- ing and Updating Treebanks: A Critical Sur- vey and Requirements Analysis. In Proceedings of the Australasian Language Technology Work- shop 2004.", |
| "links": null |
| }, |
| "BIBREF11": { |
| "ref_id": "b11", |
| "title": "Finite-state transducers in language and speech processing", |
| "authors": [ |
| { |
| "first": "Mehryar", |
| "middle": [], |
| "last": "Mohri", |
| "suffix": "" |
| } |
| ], |
| "year": 1997, |
| "venue": "Computational Linguistics", |
| "volume": "23", |
| "issue": "2", |
| "pages": "269--311", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Mehryar Mohri. 1997. Finite-state transducers in language and speech processing. Computa- tional Linguistics, 23(2):269-311.", |
| "links": null |
| }, |
| "BIBREF12": { |
| "ref_id": "b12", |
| "title": "Taxonomy of XML Schema Languages using Formal Language Theory", |
| "authors": [ |
| { |
| "first": "Makoto", |
| "middle": [], |
| "last": "Murata", |
| "suffix": "" |
| }, |
| { |
| "first": "Dongwon", |
| "middle": [], |
| "last": "Lee", |
| "suffix": "" |
| }, |
| { |
| "first": "Murali", |
| "middle": [], |
| "last": "Mani", |
| "suffix": "" |
| } |
| ], |
| "year": 2000, |
| "venue": "Proceedings of Extreme Markup Languages", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Makoto Murata, Dongwon Lee, and Murali Mani. 2000. Taxonomy of XML Schema Languages us- ing Formal Language Theory. In Proceedings of Extreme Markup Languages 2000.", |
| "links": null |
| }, |
| "BIBREF13": { |
| "ref_id": "b13", |
| "title": "Natural languages and context-free languages", |
| "authors": [ |
| { |
| "first": "Geoffrey", |
| "middle": [], |
| "last": "Pullum", |
| "suffix": "" |
| }, |
| { |
| "first": "Gerald", |
| "middle": [], |
| "last": "Gazdar", |
| "suffix": "" |
| } |
| ], |
| "year": 1982, |
| "venue": "Linguistics and Philosophy", |
| "volume": "4", |
| "issue": "", |
| "pages": "471--504", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Geoffrey Pullum and Gerald Gazdar. 1982. Nat- ural languages and context-free languages. Lin- guistics and Philosophy, 4:471-504.", |
| "links": null |
| }, |
| "BIBREF14": { |
| "ref_id": "b14", |
| "title": "TGrep2 User Manual. William Rounds. 1970. Mappings and Grammars on", |
| "authors": [ |
| { |
| "first": "Douglas", |
| "middle": [], |
| "last": "Rohde", |
| "suffix": "" |
| } |
| ], |
| "year": 2001, |
| "venue": "Trees. Mathematical Systems Theory", |
| "volume": "4", |
| "issue": "", |
| "pages": "257--287", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Douglas Rohde, 2001. TGrep2 User Manual. William Rounds. 1970. Mappings and Gram- mars on Trees. Mathematical Systems Theory, 4:257-287.", |
| "links": null |
| }, |
| "BIBREF15": { |
| "ref_id": "b15", |
| "title": "Evidence against the context-freeness of natural language", |
| "authors": [ |
| { |
| "first": "Stuart", |
| "middle": [], |
| "last": "Shieber", |
| "suffix": "" |
| } |
| ], |
| "year": 1985, |
| "venue": "Linguistics and Philosophy", |
| "volume": "8", |
| "issue": "", |
| "pages": "333--343", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Stuart Shieber. 1985. Evidence against the context-freeness of natural language. Linguistics and Philosophy, 8:333-343.", |
| "links": null |
| }, |
| "BIBREF16": { |
| "ref_id": "b16", |
| "title": "Containment for XPath Fragments under DTD Constraints", |
| "authors": [ |
| { |
| "first": "Peter", |
| "middle": [], |
| "last": "Wood", |
| "suffix": "" |
| } |
| ], |
| "year": 2003, |
| "venue": "Proceedings of the 9th International Conference on Database Theory", |
| "volume": "", |
| "issue": "", |
| "pages": "300--314", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Peter Wood. 2003. Containment for XPath Frag- ments under DTD Constraints. In Proceedings of the 9th International Conference on Database Theory, pages 300-314. XPath. 1999. XML Path Language (XPath), Version 1.0. Available on: http://www.iw3.org/TR/xpath.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "num": null, |
| "text": "Derivation for RTG G 1", |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "FIGREF1": { |
| "num": null, |
| "text": "Tree matching a//b[ * /i]/g, and corresponding tree pattern searchers have been interested in the properties of different fragments of XPath, denoted XP {[]} , XP {[], * } and XP {[], * ,//} , depending on which XPath constructs are included in the fragment.", |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "FIGREF2": { |
| "num": null, |
| "text": "Figure 3. Such a query could be expressed as Tree with sequence of VPs and NPs /child{0,inf}::VP::{0,all} /child{0,inf}::NP::{0,all}", |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "FIGREF3": { |
| "num": null, |
| "text": "Figure 4: Pattern tree for Example 3.3", |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "FIGREF4": { |
| "num": null, |
| "text": "Proposals for cross-serial dependencies results on recognition complexity.", |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "FIGREF5": { |
| "num": null, |
| "text": "inf}::V[/child::V']::{0,all} in order to match only those trees with appropriately paired NPs and Vs. 1 Notationally, this might be represented as: /child{X=|{0,inf}|}::VP[/child::NP]::{0,all} /child::VP /child{X=|{0,inf}|}::V[/child::V']::{0,all}", |
| "uris": null, |
| "type_str": "figure" |
| } |
| } |
| } |
| } |
