Datasets:

WINGNUS
/

ACL-OCL

	{
	"paper_id": "J11-1008",
	"header": {
	"generated_with": "S2ORC 1.0.0",
	"date_generated": "2023-01-19T03:05:46.647865Z"
	},
	"title": "Grammar Factorization by Tree Decomposition",
	"authors": [
	{
	"first": "Daniel",
	"middle": [],
	"last": "Gildea",
	"suffix": "",
	"affiliation": {
	"laboratory": "",
	"institution": "University of Rochester",
	"location": {}
	},
	"email": "gildea@cs.rochester.edu"
	}
	],
	"year": "",
	"venue": null,
	"identifiers": {},
	"abstract": "We describe the application of the graph-theoretic property known as treewidth to the problem of finding efficient parsing algorithms. This method, similar to the junction tree algorithm used in graphical models for machine learning, allows automatic discovery of efficient algorithms such as the O(n 4) algorithm for bilexical grammars of Eisner and Satta. We examine the complexity of applying this method to parsing algorithms for general Linear Context-Free Rewriting Systems. We show that any polynomial-time algorithm for this problem would imply an improved approximation algorithm for the well-studied treewidth problem on general graphs.",
	"pdf_parse": {
	"paper_id": "J11-1008",
	"_pdf_hash": "",
	"abstract": [
	{
	"text": "We describe the application of the graph-theoretic property known as treewidth to the problem of finding efficient parsing algorithms. This method, similar to the junction tree algorithm used in graphical models for machine learning, allows automatic discovery of efficient algorithms such as the O(n 4) algorithm for bilexical grammars of Eisner and Satta. We examine the complexity of applying this method to parsing algorithms for general Linear Context-Free Rewriting Systems. We show that any polynomial-time algorithm for this problem would imply an improved approximation algorithm for the well-studied treewidth problem on general graphs.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Abstract",
	"sec_num": null
	}
	],
	"body_text": [
	{
	"text": "In this article, we describe meta-algorithms for parsing: algorithms for finding the optimal parsing algorithm for a given grammar, with the constraint that rules in the grammar are considered independently of one another. In order to have a common representation for our algorithms to work with, we represent parsing algorithms as weighted deduction systems (Shieber, Schabes, and Pereira 1995; Goodman 1999; Nederhof 2003) . Weighted deduction systems consist of axioms and rules for building items or partial results. Items are identified by square brackets, with their weights written to the left. Figure 1 shows a rule for deducing a new item when parsing a context free grammar (CFG) with the rule S \u2192 A B. The item below the line, called the consequent, can be derived if the two items above the line, called the antecedents, have been derived. Items have types, corresponding to grammar nonterminals in this example, and variables, whose values range over positions in the string to be parsed. We restrict ourselves to items containing position variables directly as arguments; no other functions or operations are allowed to apply to variables. The consequent's weight is the product of the weights of the two antecedents and the rule weight w 0 . Implicit in the notation is the fact that we take the maximum weight over all derivations of the same item. Thus, the weighted deduction system corresponds to the Viterbi or max-product algorithm for parsing. Applications of the same weighted deduction system with other semirings are also possible (Goodman 1999) .",
	"cite_spans": [
	{
	"start": 359,
	"end": 395,
	"text": "(Shieber, Schabes, and Pereira 1995;",
	"ref_id": "BIBREF32"
	},
	{
	"start": 396,
	"end": 409,
	"text": "Goodman 1999;",
	"ref_id": "BIBREF16"
	},
	{
	"start": 410,
	"end": 424,
	"text": "Nederhof 2003)",
	"ref_id": "BIBREF28"
	},
	{
	"start": 1556,
	"end": 1570,
	"text": "(Goodman 1999)",
	"ref_id": "BIBREF16"
	}
	],
	"ref_spans": [
	{
	"start": 602,
	"end": 610,
	"text": "Figure 1",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "The computational complexity of parsing depends on the total number of instantiations of variables in the system's deduction rules. If the total number of instantiations is M, parsing is O(M) if there are no cyclic dependencies among instantiations, or, equivalently, if all instantiations can be sorted topologically. In most parsing algorithms, variables range over positions in the input string. In order to determine complexity in the length n of the input string, it is sufficient to count the number of unique position variables in each rule. If all rules have at most k position variables, M = O(n k ), and parsing takes time O(n k ) in the length of the input string. In the remainder of this article, we will explore methods for minimizing k, the largest number of position variables in any rule, among equivalent deduction systems. These methods directly minimize the parsing complexity of the resulting deduction system. Although we will assume no cyclic dependencies among rule instantiations for the majority of the article, we will discuss the cyclic case in Section 2.2.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "w 1 : [A, x 0 , x 1 ] w 2 : [B, x 1 , x 2 ] w 0 w 1 w 2 : [S, x 0 , x 2 ]",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "It is often possible to improve the computational complexity of a deduction rule by decomposing the computation into two or more new rules, each having a smaller number of variables than the original rule. We refer to this process as factorization. One straightforward example of rule factorization is the binarization of a CFG, as shown in Figure 2 . Given a deduction rule for a CFG rule with r nonterminals on the righthand side, and a total of r + 1 variables, an equivalent set of rules can be produced, each with three variables, storing intermediate results that indicate that a substring of the original rule's righthand side has been recognized. This type of rule factorization produces an O(n 3 ) parser for any input CFG.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 341,
	"end": 349,
	"text": "Figure 2",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "Another well-known instance of rule factorization is the hook trick of Eisner and Satta (1999) , which reduces the complexity of parsing for bilexicalized CFGs from O(n 5 ) to O(n 4 ). The basic rule for bilexicalized parsing combines two CFG constituents marked with lexical heads as shown in Figure 3a . Here items with type C indicate constituents, with [C, x 0 , h, x 1 ] indicating a constituent extending from position x 0 to position x 1 , headed by the word at position h. The item [D, m \u2192 h] is used to indicate the weight assigned by the grammar to a bilexical dependency headed by the word at a)",
	"cite_spans": [
	{
	"start": 71,
	"end": 94,
	"text": "Eisner and Satta (1999)",
	"ref_id": "BIBREF10"
	},
	{
	"start": 490,
	"end": 500,
	"text": "[D, m \u2192 h]",
	"ref_id": null
	}
	],
	"ref_spans": [
	{
	"start": 294,
	"end": 303,
	"text": "Figure 3a",
	"ref_id": "FIGREF1"
	}
	],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "w 1 : [A, x 0 , x 1 ] w 2 : [B, x 1 , x 2 ] w 3 : [C, x 2 , x 3 ] w 4 : [D, x 3 , x 4 ] w 0 w 1 w 2 w 3 w 4 : [S, x 0 , x 4 ] b) w 1 : [A, x 0 , x 1 ] w 2 : [B, x 1 , x 2 ] w 1 w 2 : [X, x 0 , x 2 ] w 5 : [X, x 0 , x 2 ] w 3 : [C, x 2 , x 3 ] w 3 w 5 : [Y, x 0 , x 3 ] w 6 : [Y, x 0 , x 3 ] w 3 : [D, x 3 , x 4 ] w 0 w 3 w 6 : [S, x 0 , x 3 ]",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "Binarization of the CFG rule S \u2192 A B C D as rule factorization: The deduction rule above can be factored into the three equivalent rule below.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 2",
	"sec_num": null
	},
	{
	"text": "w position h with the word at position m as a modifier. The deduction rule is broken into two steps, one which includes the weight for the bilexical grammar rule, and another which identifies the boundaries of the new constituent, as shown in Figure 3b . The hook trick has also been applied to Tree Adjoining Grammar (TAG; Eisner and Satta 2000) , and has been generalized to improve the complexity of machine translation decoding under synchronous context-free grammars (SCFGs) with an n-gram language model (Huang, Zhang, and Gildea 2005) .",
	"cite_spans": [
	{
	"start": 324,
	"end": 346,
	"text": "Eisner and Satta 2000)",
	"ref_id": "BIBREF11"
	},
	{
	"start": 510,
	"end": 541,
	"text": "(Huang, Zhang, and Gildea 2005)",
	"ref_id": "BIBREF17"
	}
	],
	"ref_spans": [
	{
	"start": 243,
	"end": 252,
	"text": "Figure 3b",
	"ref_id": "FIGREF1"
	}
	],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": ": [D, m \u2192 h] w 1 : [C, x 0 , h, x 1 ] w 2 : [C, x 1 , m, x 2 ] w w 1 w 2 : [C, x 0 , h, x 2 ] b) w : [D, m \u2192 h] w 2 : [C, x 1 , m, x 2 ] w w 2 : [H, h, x 1 , x 2 ] w h : [H, h, x 1 , x 2 ] w 1 : [C, x 0 , h, x 1 ] w h w 1 : [C, x 0 , h, x 2 ]",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": "Rule factorization has also been studied in the context of parsing for SCFGs. Unlike monolingual CFGs, SCFGs cannot always be binarized; depending on the permutation between nonterminals in the two languages, it may or may not be possible to reduce the rank, or number of nonterminals on the righthand side, of a rule. Algorithms for finding the optimal rank reduction of a specific rule are given by Zhang and Gildea (2007) . The complexity of synchronous parsing for a rule of rank r is O(n 2r+2 ), so reducing rank improves parsing complexity.",
	"cite_spans": [
	{
	"start": 401,
	"end": 424,
	"text": "Zhang and Gildea (2007)",
	"ref_id": "BIBREF35"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": "Rule factorization has also been applied to Linear Context-Free Rewriting Systems (LCFRS), which generalize CFG, TAG, and SCFG to define a rewriting system where nonterminals may have arbitrary fan-out, which indicates the number of continuous spans that a nonterminal accounts for in the string (Vijay-Shankar, Weir, and Joshi 1987) . Recent work has examined the problem of factorization of LCFRS rules in order to reduce rank without increasing grammar fan-out (G\u00f3mez-Rodr\u00edguez et al. 2009) , as well as factorization with the goal of directly minimizing the parsing complexity of the new grammar (Gildea 2010) .",
	"cite_spans": [
	{
	"start": 296,
	"end": 333,
	"text": "(Vijay-Shankar, Weir, and Joshi 1987)",
	"ref_id": "BIBREF33"
	},
	{
	"start": 464,
	"end": 493,
	"text": "(G\u00f3mez-Rodr\u00edguez et al. 2009)",
	"ref_id": "BIBREF15"
	},
	{
	"start": 600,
	"end": 613,
	"text": "(Gildea 2010)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": "We define factorization as a process which applies to rules of the input grammar independently. Individual rules are replaced with an equivalent set of new rules, which must derive the same set of consequent items as the original rule given the same antecedent items. While new intermediate items of distinct types may be produced, the set of items and weights derived by the original weighted deduction system is unchanged. This definition of factorization is broad enough to include all of the previous examples, but does not include, for example, the fold/unfold operation applied to grammars by Johnson (2007) and Eisner and Blatz (2007) . Rule factorization corresponds to the unfold operation of fold/unfold.",
	"cite_spans": [
	{
	"start": 599,
	"end": 613,
	"text": "Johnson (2007)",
	"ref_id": "BIBREF20"
	},
	{
	"start": 618,
	"end": 641,
	"text": "Eisner and Blatz (2007)",
	"ref_id": "BIBREF9"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": "If we allow unrestricted transformations of the input deduction system, finding the most efficient equivalent system is undecidable; this follows from the fact that it is undecidable whether a CFG generates the set of all strings (Bar-Hillel, Perles, and Shamir 1961), and would therefore be recognizable in constant time. Whereas the fold/unfold operation of Johnson (2007) and Eisner and Blatz (2007) specifies a narrower class of grammar transformations, no general algorithms are known for identifying an optimal series of transformations in this setting. Considering input rules independently allows us to provide algorithms for optimal factorization.",
	"cite_spans": [
	{
	"start": 360,
	"end": 374,
	"text": "Johnson (2007)",
	"ref_id": "BIBREF20"
	},
	{
	"start": 379,
	"end": 402,
	"text": "Eisner and Blatz (2007)",
	"ref_id": "BIBREF9"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": "In this article, we wish to provide a general framework for factorization of deductive parsing systems in order to minimize computational complexity. We show how to apply the graph-theoretic property of treewidth to the factorization problem, and examine the question of whether efficient algorithms exist for optimizing the parsing complexity of general parsing systems in this framework. In particular, we show that the existence of a polynomial time algorithm for optimizing the parsing complexity of general LCFRS rules would imply an improved approximation algorithm for the wellstudied problem of treewidth of general graphs.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "a)",
	"sec_num": null
	},
	{
	"text": "In this section, we introduce the graph-theoretic property known as treewidth, and show how it can be applied to rule factorization.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "A tree decomposition of a graph G = (V, E) is a type of tree having a subset of G's vertices at each node. We define the nodes of this tree T to be the set I, and its edges to be the set F. The subset of V associated with node i of T is denoted by X i . A tree decomposition is therefore defined as a pair ({X",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "i \| i \u2208 I}, T = (I, F)) where each X i , i \u2208 I",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "is a subset of V, and tree T has the following properties:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "r Vertex cover: The nodes of the tree T cover all the vertices of G:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "i\u2208I X i = V. r Edge cover: Each edge in G is included in some node of T. That is, for all edges (u, v) \u2208 E, there exists an i \u2208 I with u, v \u2208 X i .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "r Running intersection: The nodes of T containing a given vertex of G form a connected subtree. Mathematically, for all i, j, k \u2208 I, if j is on the (unique)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "path from i to k in T, then X i X k \u2286 X j .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "The treewidth of a tree decomposition",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "({X i }, T) is max i \|X i \| \u2212 1.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "The treewidth of a graph is the minimum treewidth over all tree decompositions:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "tw(G) = min ({X i },T)\u2208TD(G) max i \|X i \| \u2212 1",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "where TD(G) is the set of valid tree decompositions of G. We refer to a tree decomposition achieving the minimum possible treewidth as being optimal. In general, more densely interconnected graphs have higher treewidth. Any tree has treewidth = 1; a graph consisting of one large cycle has treewidth = 2, and a fully connected graph of n vertices has treewidth = n \u2212 1. Low treewidth indicates some treelike structure in the graph, as shown by the example with treewidth = 2 in Figure 4 . As an example of the running intersection property, note that the vertex N appears in three adjacent nodes of the tree decomposition. Finding the treewidth of a graph is an NPcomplete problem (Arnborg, Corneil, and Proskurowski 1987) . However, given a graph of n vertices and treewidth k, a simple algorithm finds the optimal tree decomposition in time O(n k+2 ) (Arnborg, Corneil, and Proskurowski 1987) , and a variety of approximation algorithms and heuristics are known for the treewidth problem (Bodlaender et al. 1995; Amir 2001; Feige, Hajiaghayi, and Lee 2005) . Furthermore, for fixed k, optimal tree decompositions can be computed in linear time (Bodlaender 1996) . A tree decomposition of a graph is a set of overlapping clusters of the graph's vertices, arranged in a tree. This example has treewidth = 2.",
	"cite_spans": [
	{
	"start": 681,
	"end": 722,
	"text": "(Arnborg, Corneil, and Proskurowski 1987)",
	"ref_id": "BIBREF2"
	},
	{
	"start": 853,
	"end": 894,
	"text": "(Arnborg, Corneil, and Proskurowski 1987)",
	"ref_id": "BIBREF2"
	},
	{
	"start": 990,
	"end": 1014,
	"text": "(Bodlaender et al. 1995;",
	"ref_id": "BIBREF5"
	},
	{
	"start": 1015,
	"end": 1025,
	"text": "Amir 2001;",
	"ref_id": "BIBREF1"
	},
	{
	"start": 1026,
	"end": 1058,
	"text": "Feige, Hajiaghayi, and Lee 2005)",
	"ref_id": "BIBREF12"
	},
	{
	"start": 1146,
	"end": 1163,
	"text": "(Bodlaender 1996)",
	"ref_id": "BIBREF4"
	}
	],
	"ref_spans": [
	{
	"start": 478,
	"end": 486,
	"text": "Figure 4",
	"ref_id": "FIGREF2"
	}
	],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "We can factorize a deduction rule by representing the rule as a graph, which we call a dependency graph, and searching for tree decompositions of this graph. For a rule r having n variables",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "V = {v i \| i \u2208 {1, . . . , n}}, m antecedent items A i , i \u2208 {1, . . . , m}, and consequent C, let V(A i ) \u2282 V",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "be the variables appearing in antecedent A i , and V(C) be the variables appearing in the consequent. The dependency graph representation of the rule is",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "G r = (V, E = S:A 1 ,...,A m ,C {(v i , v j ) \| v i , v j \u2208 V(S)}).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "That is, we have a vertex for each variable in the rule, and connect any two vertices that appear together in the same antecedent, or that appear together in the consequent.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "The dependency graph representation allows us to prove the following result concerning parsing complexity:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Treewidth and Rule Factorization",
	"sec_num": "2."
	},
	{
	"text": "Given a deduction rule r for parsing where the input string is referenced only through position variables appearing as arguments of antecedent and consequent items, the optimal complexity of any factorization of rule r is O(n tw(G r )+1 ), where G r is the dependency graph derived from r.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 1",
	"sec_num": null
	},
	{
	"text": "One consequence of the definition of a tree decomposition is that, for any clique appearing in the original graph G r , there must exist a node in the tree decomposition T which contains all the vertices in the clique. We use this fact to show that there is a one-toone correspondence between tree decompositions of a rule's dependency graph G r and factorizations of the rule.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "First, we need to show that any tree decomposition of G r can be used as a factorization of the original deduction rule. By our earlier definition, a factorization must derive the same set of consequent items from a given set of antecedent items as the original rule. Because G r includes a clique connecting all variables in the consequent C, the tree decomposition T must have a node X c such that V(C) \u2286 X c . We consider this node to be the root of T. The original deduction rule can be factorized into a new set of rules, one for each node in T. For node X c , the factorized rule has C as a consequent, and all other nodes X i have a new partial result as a consequent, consisting of the variables X i \u2229 X j , where X j is X i 's neighbor on the path to the root node X c . We must guarantee that the factorized rule set yields the same result as the original rule, namely, the semiring sum over all variable values of the semiring product of the antecedents' weights. The tree structure of T corresponds to a factorization of this semiring expression. For example, if we represent the CFG rule of Figure 2a with the generalized semiring expression:",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 1104,
	"end": 1113,
	"text": "Figure 2a",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "x 1 x 2 x 3 A(x 0 , x 1 ) \u2297 B(x 1 , x 2 ) \u2297 C(x 2 , x 3 ) \u2297 D(x 3 , x 4 )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "the factorization of this expression corresponding to the binarized rule is",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "x 3 x 2 x 1 A(x 0 , x 1 ) \u2297 B(x 1 , x 2 ) \u2297 C(x 2 , x 3 ) \u2297 D(x 3 , x 4 )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "where semiring operations \u2295 and \u2297 have been interchanged as allowed by the dependency graph for this rule. Because each antecedent A i is represented by a clique in the graph G r , the tree decomposition T must contain at least one node which includes all variables V(A i ). We can choose one such node and multiply in the weight of A i , given the values of variables V(A i ), at this step of the expression. The running intersection property of the tree decomposition guarantees that each variable has a consistent value at each point where it is referenced in the factorization.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "The same properties guarantee that any valid rule factorization corresponds to a tree decomposition of the graph G r . We consider the tree decomposition with a set X i for each new rule r i , consisting of all variables used in r i , and with tree edges T defined by the producer/consumer relation over intermediate results in the rule factorization. Each antecedent of the original rule must appear in some new rule in the factorization, as must the consequent of the original rule. Therefore, all edges in the original rule's dependency graph G r appear in some tree node X i . Any variable that appears in two rules in the factorization must appear in all intermediate rules in order to ensure that the variable has a consistent value in all rules that reference it. This guarantees the running intersection property of the tree decomposition ({X i }, T). Thus any rule factorization, when viewed as a tree of sets of variables, has the properties that make it a valid tree decomposition of G r .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "The theorem follows as a consequence of the one-to-one correspondence between rule factorizations and tree decompositions.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof",
	"sec_num": null
	},
	{
	"text": "Factorization produces, for each input rule having m antecedents, at most m \u2212 1 new rules, each containing at most the same number of nonterminals and the same number of variables as the input rule. Hence, the size of the new factorized grammar is O(\|G\| 2 ), and we avoid any possibility of an exponential increase in grammar size. Tighter bounds can be achieved for specific classes of input grammars.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Computational Complexity",
	"sec_num": "2.1"
	},
	{
	"text": "The computational complexity of optimal factorization with tree decomposition is exponential in the size of the input rules. However, optimal factorization is generally feasible whenever parsing with the unfactorized grammar is feasible. This is because, for an input rule with variables, parsing is O(n ) in the sentence length n. The treewidth of this rule is at most \u2212 1, and can be computed in time O( +1 ); generally we expect n to be greater than . One may also wish to accept only rules having treewidth k and disregard the remainder, for example, when factorizing rules automatically extracted from word-aligned bitext (Wellington, Waxmonsky, and Melamed 2006; Huang et al. 2009) or from dependency treebanks (Kuhlmann and Nivre 2006; Gildea 2010) . In this setting, the rules having treewidth k can be identified in time O( k+2 ) using the simple algorithm of Arnborg, Corneil, and Proskurowski (1987) , (where again is the number of variables in the input rules), or in time O( ) using the algorithm of Bodlaender (1996) .",
	"cite_spans": [
	{
	"start": 627,
	"end": 668,
	"text": "(Wellington, Waxmonsky, and Melamed 2006;",
	"ref_id": null
	},
	{
	"start": 669,
	"end": 687,
	"text": "Huang et al. 2009)",
	"ref_id": "BIBREF18"
	},
	{
	"start": 717,
	"end": 742,
	"text": "(Kuhlmann and Nivre 2006;",
	"ref_id": "BIBREF23"
	},
	{
	"start": 743,
	"end": 755,
	"text": "Gildea 2010)",
	"ref_id": null
	},
	{
	"start": 869,
	"end": 910,
	"text": "Arnborg, Corneil, and Proskurowski (1987)",
	"ref_id": "BIBREF2"
	},
	{
	"start": 1013,
	"end": 1030,
	"text": "Bodlaender (1996)",
	"ref_id": "BIBREF4"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Computational Complexity",
	"sec_num": "2.1"
	},
	{
	"text": "Although this article primarily addresses the case where there are no cyclic dependencies between rule instantiations, we note here that our techniques carry over to the cyclic case under certain conditions. If there are cycles in the rule dependencies, but the semiring meets Knuth's (1977) definition of a superior function, parsing takes time O(M log M), where M is the number of rule instantiations, and the extra log M term accounts for maintaining an agenda as a priority queue (Nederhof 2003) . Cycles in the rule dependencies may arise, for example, from chains of unary productions in a CFG; the properties of superior functions guarantee that unbounded chains need not be considered. The max-product semiring used in Viterbi parsing has this property, assuming that all rule weights are less than one, whereas for exact computation with the sum-product semiring, unbounded chains must be considered. As in the acyclic case, M = O(n k ) for parsing problems where rules have at most k variables. Under the assumption of superior functions, parsing takes time O(n k k log n) with Knuth's algorithm. In this setting, as in the acyclic case, minimizing k with tree decomposition minimizes parsing complexity.",
	"cite_spans": [
	{
	"start": 277,
	"end": 291,
	"text": "Knuth's (1977)",
	"ref_id": "BIBREF21"
	},
	{
	"start": 484,
	"end": 499,
	"text": "(Nederhof 2003)",
	"ref_id": "BIBREF28"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Cyclic Dependencies",
	"sec_num": "2.2"
	},
	{
	"text": "The technique of using treewidth to minimize complexity has been applied to constraint satisfaction (Dechter and Pearl 1989) , graphical models in machine learning (Jensen, Lauritzen, and Olesen 1990; Shafer and Shenoy 1990) , and query optimization for databases (Chekuri and Rajaraman 1997) . Our formulation of parsing is most closely related to logic programming; in this area treewidth has been applied to limit complexity in settings where either the deduction rules or the input database of ground facts have fixed treewidth (Flum, Frick, and Grohe 2002) . Whereas Flum, Frick, and Grohe (2002) apply treewidth to nonrecursive datalog programs, our parsing programs have unbounded recursion, as the depth of the parse tree is not fixed in advance. Our results for parsing can be seen as a consequence of the fact that, even in the case of unbounded recursion, the complexity of (unweighted) datalog programs is linear in the number of possible rule instantiations (McAllester 2002) .",
	"cite_spans": [
	{
	"start": 100,
	"end": 124,
	"text": "(Dechter and Pearl 1989)",
	"ref_id": "BIBREF8"
	},
	{
	"start": 164,
	"end": 200,
	"text": "(Jensen, Lauritzen, and Olesen 1990;",
	"ref_id": "BIBREF19"
	},
	{
	"start": 201,
	"end": 224,
	"text": "Shafer and Shenoy 1990)",
	"ref_id": "BIBREF31"
	},
	{
	"start": 264,
	"end": 292,
	"text": "(Chekuri and Rajaraman 1997)",
	"ref_id": "BIBREF6"
	},
	{
	"start": 532,
	"end": 561,
	"text": "(Flum, Frick, and Grohe 2002)",
	"ref_id": "BIBREF13"
	},
	{
	"start": 564,
	"end": 601,
	"text": "Whereas Flum, Frick, and Grohe (2002)",
	"ref_id": null
	},
	{
	"start": 971,
	"end": 988,
	"text": "(McAllester 2002)",
	"ref_id": "BIBREF25"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Applications of Treewidth",
	"sec_num": "2.3"
	},
	{
	"text": "In this section, we show how a few well-known parsing algorithms can be derived automatically by finding the optimal tree decomposition of a dependency graph.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Examples of Treewidth for Parsing",
	"sec_num": "3."
	},
	{
	"text": "To aid in visualization of the graphical representation of deduction rules, we use a factor graph representation based on that of Kschischang, Frey, and Loeliger (2001) for Markov Random Fields. Our graphs have three types of nodes: variables, antecedents, and consequents. Each antecedent node is connected to the variables it contains, and represents the antecedent's weight as a function of those variables. Antecedent nodes are analogous to the factor nodes of Kschischang, Frey, and Loeliger (2001) , and consequent nodes are a new feature of this representation. We can think of consequents as factors with weight = 1; they do not affect the weights computed, but serve to guarantee that the consequent of the original rule can be found in one node of the tree decomposition. We refer to both antecedent and consequent nodes as factor nodes. Replacing each factor node with a clique over its neighbor variables yields the dependency graph G r defined earlier. We represent variables with circles, antecedents with squares labeled with the antecedent's weight, and consequents with diamonds labeled c. An example factor graph for the simple CFG rule of Figure 1 is shown in Figure 5 . Figure 6a shows the factor graph derived from the monolingual CFG rule with four children in Figure 2a . The dependency graph obtained by replacing each factor with a clique of size 2 (a single edge) is a graph with one large cycle, shown in Figure 6b . Finding the optimal tree decomposition yields a tree with nodes of size 3, {x 0 , x i , x i+1 } for each i, shown in Figure 6c . Each node in this tree decomposition corresponds to one of the factored deduction rules in Figure 2b . Thus, the tree decomposition shows us how",
	"cite_spans": [
	{
	"start": 130,
	"end": 168,
	"text": "Kschischang, Frey, and Loeliger (2001)",
	"ref_id": "BIBREF22"
	},
	{
	"start": 465,
	"end": 503,
	"text": "Kschischang, Frey, and Loeliger (2001)",
	"ref_id": "BIBREF22"
	}
	],
	"ref_spans": [
	{
	"start": 1158,
	"end": 1166,
	"text": "Figure 1",
	"ref_id": "FIGREF0"
	},
	{
	"start": 1179,
	"end": 1187,
	"text": "Figure 5",
	"ref_id": "FIGREF3"
	},
	{
	"start": 1190,
	"end": 1199,
	"text": "Figure 6a",
	"ref_id": null
	},
	{
	"start": 1283,
	"end": 1292,
	"text": "Figure 2a",
	"ref_id": null
	},
	{
	"start": 1432,
	"end": 1441,
	"text": "Figure 6b",
	"ref_id": null
	},
	{
	"start": 1561,
	"end": 1570,
	"text": "Figure 6c",
	"ref_id": null
	},
	{
	"start": 1664,
	"end": 1673,
	"text": "Figure 2b",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Examples of Treewidth for Parsing",
	"sec_num": "3."
	},
	{
	"text": "Treewidth applied to CFG binarization. to parse in time O(n 3 ); finding the tree decomposition of a long CFG rule is essentially equivalent to converting to Chomsky Normal Form.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 6",
	"sec_num": null
	},
	{
	"text": "The deduction rule for bilexicalized parsing shown in Figure 3a translates into the factor graph shown in Figure 7a . Factor nodes are created for the two existing constituents from the chart, with the first extending from position x 0 in the string to x 1 , and the second from x 1 to x 2 . Both factor nodes are connected not only to the start and end points, but also to the constituent's head word, h for the first constituent and m for the second (we show the construction of a left-headed constituent in the figure) . An additional factor is connected only to h and m to represent the bilexicalized rule weight, expressed as a function of h and m, which is multiplied with the weight of the two existing constituents to derive the weight of the new constituent. The new constituent is represented by a consequent node at the top of the graph-the variables that will be relevant for its further combination with other constituents are its end points x 0 and x 2 and its head word h.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 54,
	"end": 63,
	"text": "Figure 3a",
	"ref_id": "FIGREF1"
	},
	{
	"start": 106,
	"end": 115,
	"text": "Figure 7a",
	"ref_id": null
	},
	{
	"start": 514,
	"end": 521,
	"text": "figure)",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "The Hook Trick",
	"sec_num": "3.2"
	},
	{
	"text": "Placing an edge between each pair of variable nodes that share a factor, we get Figure 7b. If we compute the optimal tree decomposition for this graph, shown in Figure 7c , each of the two nodes corresponds to one of the factored rules in Figure 3b . The largest node of the tree decomposition has four variables, giving the O(n 4 ) algorithm of Eisner and Satta (1999) .",
	"cite_spans": [
	{
	"start": 346,
	"end": 369,
	"text": "Eisner and Satta (1999)",
	"ref_id": "BIBREF10"
	}
	],
	"ref_spans": [
	{
	"start": 80,
	"end": 86,
	"text": "Figure",
	"ref_id": null
	},
	{
	"start": 161,
	"end": 170,
	"text": "Figure 7c",
	"ref_id": null
	},
	{
	"start": 239,
	"end": 248,
	"text": "Figure 3b",
	"ref_id": "FIGREF1"
	}
	],
	"eq_spans": [],
	"section": "The Hook Trick",
	"sec_num": "3.2"
	},
	{
	"text": "SCFGs generalize CFGs to generate two strings with isomorphic hierarchical structure simultaneously, and have become widely used as statistical models of machine translation (Galley et al. 2004; Chiang 2007) . We write SCFG rules as productions with one",
	"cite_spans": [
	{
	"start": 174,
	"end": 194,
	"text": "(Galley et al. 2004;",
	"ref_id": "BIBREF14"
	},
	{
	"start": 195,
	"end": 207,
	"text": "Chiang 2007)",
	"ref_id": "BIBREF7"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "SCFG Parsing Strategies",
	"sec_num": "3.3"
	},
	{
	"text": "Treewidth applied to bilexicalized parsing. lefthand side nonterminal and two righthand side strings. Nonterminals in the two strings are linked with superscript indices; symbols with the same index must be further rewritten synchronously. For example,",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "EQUATION",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [
	{
	"start": 0,
	"end": 8,
	"text": "EQUATION",
	"ref_id": "EQREF",
	"raw_str": "X \u2192 A (1) B (2) C (3) D (4) , A (1) B (2) C (3) D (4)",
	"eq_num": "(1)"
	}
	],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "is a rule with four children and no reordering, whereas",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "EQUATION",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [
	{
	"start": 0,
	"end": 8,
	"text": "EQUATION",
	"ref_id": "EQREF",
	"raw_str": "X \u2192 A (1) B (2) C (3) D (4) , B (2) D (4) A (1) C (3)",
	"eq_num": "(2)"
	}
	],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "expresses a more complex reordering. In general, we can take indices in the first righthand-side string to be consecutive, and associate a permutation \u03c0 with the second string. If we use X i for 0 \u2264 i \u2264 n as a set of variables over nonterminal symbols (for example, X 1 and X 2 may both stand for nonterminal A), we can write rules in the general form:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "X 0 \u2192 X (1) 1 \u2022 \u2022 \u2022 X (n) n , X (\u03c0(1)) \u03c0(1) \u2022 \u2022 \u2022 X (\u03c0(n)) \u03c0(n)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "Unlike monolingual CFGs, SCFGs cannot always be binarized. In fact, the languages of string pairs generated by a synchronous grammar can be arranged in an infinite hierarchy, with each rank \u2265 4 producing languages not possible with grammars restricted to smaller rules (Aho and Ullman 1972) . For any grammar with maximum rank r, converting each rule into a single deduction rule yields an O(n 2r+2 ) parsing algorithm, because there are r + 1 boundary variables in each language. More efficient parsing algorithms are often possible for specific permutations, and, by Theorem 1, the best algorithm for a permutation can be found by computing the minimum-treewidth tree decomposition of the graph derived from the SCFG deduction rule for a specific permutation. For example, for the non-binarizable rule of Equation (2), the resulting factor graph is shown in Figure 8a , where variables x 0 , . . . , x 4 indicate position variables in one language of the synchronous grammar, and y 0 , . . . , y 4 are positions in the other language. The optimal tree decomposition for this rule is shown in Figure 8c . For this permutation, the optimal parsing algorithm takes time O(n 8 ), because the largest node in the tree decomposition of Figure 8c includes eight position variables. This result is intermediate between the O(n 6 ) for binarizable SCFGs, also known as Inversion Transduction Grammars (Wu 1997) , and the O(n 10 ) that we would achieve by recognizing the rule in a single deduction step.",
	"cite_spans": [
	{
	"start": 269,
	"end": 290,
	"text": "(Aho and Ullman 1972)",
	"ref_id": "BIBREF0"
	},
	{
	"start": 1394,
	"end": 1403,
	"text": "(Wu 1997)",
	"ref_id": "BIBREF34"
	}
	],
	"ref_spans": [
	{
	"start": 860,
	"end": 869,
	"text": "Figure 8a",
	"ref_id": "FIGREF4"
	},
	{
	"start": 1094,
	"end": 1103,
	"text": "Figure 8c",
	"ref_id": "FIGREF4"
	},
	{
	"start": 1232,
	"end": 1241,
	"text": "Figure 8c",
	"ref_id": "FIGREF4"
	}
	],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "Gildea and\u0160tefankovi\u010d (2007) use a combinatorial argument to show that as the number of nonterminals r in an SCFG rule grows, the parsing complexity grows as \u2126(n cr ) for some constant c. In other words, some very difficult permutations exist of all lengths.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "It is interesting to note that although applying the tree decomposition technique to long CFG rules results in a deduction system equivalent to a binarized CFG, the individual deduction steps in the best parsing strategy for an SCFG rule do not in general correspond to SCFG rules. This is because the intermediate results may include more than one span in each language. These intermediate deduction steps do, however, correspond to LCFRS rules. We now turn to examine LCFRS in more detail. ",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 7",
	"sec_num": null
	},
	{
	"text": "LCFRS provides a generalization of a number of widely used formalisms in natural language processing, including CFG, TAG, SCFG, and synchronous TAG. LCFRS has also been used to model non-projective dependency grammars, and the LCFRS rules extracted from dependency treebanks can be quite complex (Kuhlmann and Satta 2009) , making factorization important. Similarly, LCFRS can model translation relations beyond the power of SCFG (Melamed, Satta, and Wellington 2004) , and grammars extracted from word-aligned bilingual corpora can also be quite complex (Wellington, Waxmonsky, and Melamed 2006) . An algorithm for factorization of LCFRS rules is presented by Gildea (2010) , exploiting specific properties of LCFRS. The tree decomposition method achieves the same results without requiring analysis specific to LCFRS. In this section, we examine the complexity of rule factorization for general LCFRS grammars.",
	"cite_spans": [
	{
	"start": 296,
	"end": 321,
	"text": "(Kuhlmann and Satta 2009)",
	"ref_id": "BIBREF24"
	},
	{
	"start": 430,
	"end": 467,
	"text": "(Melamed, Satta, and Wellington 2004)",
	"ref_id": "BIBREF26"
	},
	{
	"start": 555,
	"end": 596,
	"text": "(Wellington, Waxmonsky, and Melamed 2006)",
	"ref_id": null
	},
	{
	"start": 661,
	"end": 674,
	"text": "Gildea (2010)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "LCFRS Parsing Strategies",
	"sec_num": "4."
	},
	{
	"text": "The problem of finding the optimal factorization of an arbitrary deduction rule is NP-complete. This follows from the NP-completeness of treewidth using the following construction: Given a graph, create a deduction rule with a variable for each vertex in the graph and an antecedent for each edge, containing the two variables associated with the edge's endpoints. The graphs produced by LCFRS grammar rules, however, have certain properties which may make more efficient factorization algorithms possible. We first define LCFRS precisely before examining the properties of these graphs. N , P, S) , where V T is a set of terminal symbols, V N is a set of nonterminal symbols, P is a set of productions, and S \u2208 V N is a distinguished start symbol. Associated with each nonterminal B is a fan-out \u03d5(B), which tells how many continuous spans B covers. Productions p \u2208 P take the form:",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 588,
	"end": 597,
	"text": "N , P, S)",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "LCFRS Parsing Strategies",
	"sec_num": "4."
	},
	{
	"text": "G = (V T , V",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "EQUATION",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [
	{
	"start": 0,
	"end": 8,
	"text": "EQUATION",
	"ref_id": "EQREF",
	"raw_str": "p : A \u2192 g(B 1 , B 2 , . . . , B r )",
	"eq_num": "( 3 )"
	}
	],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "where A, B 1 , . . . , B r \u2208 V N , and g is a function",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "g : (V * T ) \u03d5(B 1 ) \u00d7 \u2022 \u2022 \u2022 \u00d7 (V * T ) \u03d5(B r ) \u2192 (V * T ) \u03d5(A)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "which specifies how to assemble the r i=1 \u03d5(B i ) spans of the righthand side nonterminals into the \u03d5(A) spans of the lefthand side nonterminal. The function g must be linear and non-erasing, which means that if we write",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "g( s 1,1 , . . . , s 1,\u03d5(B 1 ) , . . . , s 1,1 , . . . , s 1,\u03d5(B r ) ) = t 1 , . . . , t \u03d5(A)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "the tuple of strings t 1 , . . . , t \u03d5(A) on the righthand side contains each variable s i,j from the lefthand side exactly once, and may also contain terminals from V T . The process of generating a string from an LCFRS grammar can be thought of as first choosing, topdown, a production to expand each nonterminal, and then, bottom-up, applying the functions associated with each production to build the string. As an example, the CFG",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "S \u2192 A B A \u2192 a B \u2192 b",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "corresponds to the following grammar in LCFRS notation:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "S \u2192 g S (A, B) g S ( s A , s B ) = s A s B A \u2192 g A () g A () = a B \u2192 g B () g B () = b",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "Here, all nonterminals have fan-out = 1, reflected in the fact that all tuples defining the productions' functions contain just one string. As CFG is equivalent to LCFRS with fanout = 1, SCFG and TAG can be represented as LCFRS with fan-out = 2. Higher values of fan-out allow strictly more powerful grammars (Rambow and Satta 1999) . Polynomialtime parsing is possible for any fixed LCFRS grammar, but the degree of the polynomial depends on the grammar. Parsing general LCFRS grammars, where the grammar is considered part of the input, is NP-complete (Satta 1992) .",
	"cite_spans": [
	{
	"start": 309,
	"end": 332,
	"text": "(Rambow and Satta 1999)",
	"ref_id": "BIBREF29"
	},
	{
	"start": 554,
	"end": 566,
	"text": "(Satta 1992)",
	"ref_id": "BIBREF30"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "An LCFRS is defined as a tuple",
	"sec_num": null
	},
	{
	"text": "Given an LCFRS rule as defined previously, a weighted deduction rule for a bottomup parser can be derived by creating an antecedent for each righthand nonterminal, a consequent for the lefthand side, and variables for all the boundaries of the nonterminals in the rule. A nonterminal of fan-out f has 2f boundaries. Each boundary variable will occur exactly twice in the deduction rule: either in two antecedents, if two nonterminals on the rule's righthand side are adjacent, or once in an antecedent and once in the consequent, if the variable indicates a boundary of any segment of the rule's lefthand side.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Graphs Derived from LCFRS Rules",
	"sec_num": "4.1"
	},
	{
	"text": "Converting such deduction rules into dependency graphs, we see that the cliques of the dependency graph may be arbitrarily large, due to the unbounded fan-out of LCFRS nonterminals. However, each vertex appears in only two cliques, because each boundary variable in the rule is shared by exactly two nonterminals. In the remainder of this section, we consider whether the problem of finding the optimal tree decomposition of this restricted set of graphs is also NP-complete, or whether efficient algorithms may be possible in the LCFRS setting.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Graphs Derived from LCFRS Rules",
	"sec_num": "4.1"
	},
	{
	"text": "We will show that an efficient algorithm for finding the factorization of an arbitrary LCFRS production that optimizes parsing complexity would imply the existence of an algorithm for treewidth that returns a result within a factor of 4\u2206(G) of the optimum, where \u2206(G) is the maximum degree of the input graph. Although such an approximation algorithm may be possible, it would require progress in fundamental problems in graph theory.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Approximation of Treewidth for General Graphs",
	"sec_num": "4.2"
	},
	{
	"text": "Consider an arbitrary graph G = (V, E), and define k to be its treewidth, k = tw(G). We wish to construct a new graph G = (V , E ) from G in such a way that tw(G ) = tw(G) and every vertex in G has even degree. This can be accomplished by doubling the graph's edges in the manner shown in Figure 9 . To double the edges, for every edge e = (u, v) in E, we add a new vertex\u00ea to G and add edges (u,\u00ea) and (v,\u00ea) to G . We also include every edge in the original graph G in G . Now, every vertex v in G has degree = 2, if it is a newly created vertex, or twice the degree of v in G otherwise, and therefore",
	"cite_spans": [
	{
	"start": 340,
	"end": 346,
	"text": "(u, v)",
	"ref_id": null
	},
	{
	"start": 393,
	"end": 398,
	"text": "(u,\u00ea)",
	"ref_id": null
	},
	{
	"start": 403,
	"end": 408,
	"text": "(v,\u00ea)",
	"ref_id": null
	}
	],
	"ref_spans": [
	{
	"start": 289,
	"end": 297,
	"text": "Figure 9",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Approximation of Treewidth for General Graphs",
	"sec_num": "4.2"
	},
	{
	"text": "EQUATION",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [
	{
	"start": 0,
	"end": 8,
	"text": "EQUATION",
	"ref_id": "EQREF",
	"raw_str": "\u2206(G ) = 2\u2206(G)",
	"eq_num": "( 4 )"
	}
	],
	"section": "Approximation of Treewidth for General Graphs",
	"sec_num": "4.2"
	},
	{
	"text": "We now show that tw(G ) = tw(G), under the assumption that tw(G) \u2265 3. Any tree decomposition of G can be adapted to a tree decomposition of G by adding a node containing {u, v,\u00ea} for each edge e in the original graph, as shown in Figure 10 . The new node can be attached to a node containing u and v; because u and v are connected by an edge in G, such a node must exist in G's tree decomposition. The vertex\u00ea will not occur anywhere else in the tree decomposition, and the occurrences of u and v still form a connected subtree. For each edge e = (u, v) in G , the tree decomposition must have a node containing u and v; this is the case because, if e is an original edge from G, there is already a node in the tree decomposition containing u and v, whereas if e is an edge to a newly added vertex in G , one of the newly added nodes in the tree decomposition",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 230,
	"end": 239,
	"text": "Figure 10",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Approximation of Treewidth for General Graphs",
	"sec_num": "4.2"
	},
	{
	"text": "An example graph G ex and the result G ex of doubling G ex 's edges.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 9",
	"sec_num": null
	},
	{
	"text": "Tree decompositions of G ex and G ex .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "will contain its endpoints. We constructed the new tree decomposition by adding nodes of size 3. Therefore, as long as the treewidth of G was at least 3, tw(G ) \u2264 tw(G). In the other direction, because G is a subgraph of G , any tree decomposition of G forms a valid tree decomposition of G after removing the vertices in G \u2212 G, and hence tw(G ) \u2265 tw(G). Therefore, tw(G ) = tw(G)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "Because every vertex in G has even degree, G has an Eulerian tour, that is, a path visiting every edge exactly once, beginning and ending at the same vertex. Let \u03c0 = \u03c0 1 , . . . , \u03c0 n be the sequence of vertices along such a tour, with \u03c0 1 = \u03c0 n . Note that the sequence \u03c0 contains repeated elements. Let \u00b5 i , i \u2208 {1, . . . , n} indicate how many times we have visited \u03c0 i on the ith step of the tour:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "\u00b5 i = \|{j \| \u03c0 j = \u03c0 i , j \u2208 {1, . . . , i}}\|.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "We now construct an LCFRS production P with \|V \| righthand side nonterminals from the Eulerian tour:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "P : X \u2192 g(B 1 , . . . , B \|V \| ) g( s 1,1 , . . . , s 1,\u03c6(B 1 ) , . . . , s \|V \|,1 , . . . , s \|V \|,\u03c6(B \|V \| ) ) = s \u03c0 1 ,\u00b5 1 \u2022 \u2022 \u2022 s \u03c0 n ,\u00b5 n",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "The fan-out \u03c6(B i ) of each nonterminal B i is the number of times vertex i is visited on the Eulerian tour. The fan-out of the lefthand side nonterminal X is one, and the lefthand side is constructed by concatenating the spans of each nonterminal in the order specified by the Eulerian tour.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "For the example graph in Figure 9 , one valid tour is",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 25,
	"end": 33,
	"text": "Figure 9",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "\u03c0 ex = A,",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "This tour results in the following LCFRS production:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "B, C, D, F, C, E, A, G, B, H, C, A",
	"sec_num": null
	},
	{
	"text": "P ex : X \u2192 g ex (A, B, C, D, E, F, G, H) g ex ( s A,1 , s A,2 , s A,3 , s B,1 , s B,2 , s C,1 , s C,2 , s C,3 , s D,1 , s E,1 , s F,1 , s G,1 , s H,1 ) = s A,1 s B,1 s C,1 s D,1 s F,1 s C,2 s E,1 s A,2 s G,1",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "B, C, D, F, C, E, A, G, B, H, C, A",
	"sec_num": null
	},
	{
	"text": "We now construct dependency graph G from the LCFRS production P by applying the technique of Section 2. G has n + 1 vertices, corresponding to the beginning and end points of the nonterminals in P. The edges in G are formed by adding a clique for each nonterminal in P connecting all its beginning and end points, that is, 2f 2 edges for a nonterminal of fan-out f . We must include a clique for X, the lefthand side of the production. However, because the righthand side of the production begins and ends with the same nonterminal, the vertices for the beginning and end points of X are already connected, so the lefthand side does not affect the graph structure for the entire production. By Theorem 1, the optimal parsing complexity of P is tw(G ) + 1.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "The graphs G and G are related in the following manner: Every edge in G corresponds to a vertex in G , and every vertex in G corresponds to a clique in G . We can identify vertices in G with unordered pairs of vertices {u, v} in G . The edges in G are ({u, v}, {u, w}) ",
	"cite_spans": [
	{
	"start": 252,
	"end": 268,
	"text": "({u, v}, {u, w})",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "\u2200u, v, w : u = v, u = w, v = w.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "An example of G derived from our example production P ex is shown in Figure 11 .",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 69,
	"end": 78,
	"text": "Figure 11",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "Any tree decomposition T of G can be transformed into a valid tree decomposition T of G by simply replacing each vertex in each node of T with both corresponding vertices in G . If T witnesses a tree decomposition of optimal width k = tw(G ), each node in T will produce a node of size at most 2k in T . For any vertex v in G , one node in T must contain the clique corresponding to v in G . Each vertex {v, w} in G must be found in a contiguous subtree of T , and these subtrees all include the node containing the clique for v. The occurrences of v in T are the union of these contiguous subtrees, which must itself form a contiguous subtree. Furthermore, each edge (u, v) in G corresponds to some vertex in G , so u and v must occur together in some node of T . Combining these two properties, we see that T is a valid tree decomposition of G . From the construction, if SOL is the treewidth of T , we are guaranteed that",
	"cite_spans": [
	{
	"start": 668,
	"end": 674,
	"text": "(u, v)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "EQUATION",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [
	{
	"start": 0,
	"end": 8,
	"text": "EQUATION",
	"ref_id": "EQREF",
	"raw_str": "SOL \u2264 2tw(G )",
	"eq_num": "( 6 )"
	}
	],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "In the other direction, any tree decomposition T of G can be transformed into a tree decomposition T of G by simply replacing each occurrence of vertex v in a node of T with all vertices {v, w} in T . The number of such vertices is the degree of v, \u2206(v).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "s B,2 s H,1 s C,3 s A,3",
	"sec_num": null
	},
	{
	"text": "Dependency graph G ex derived from the example of Figure 9 . Vertex #A corresponds to the beginning of the Eulerian tour through G ex and A# corresponds to the end of the tour; all other vertices correspond to edges in G ex .",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 50,
	"end": 58,
	"text": "Figure 9",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "Each vertex {v, w} occurs in a contiguous subtree of T because v and w occurred in contiguous subtrees of T , and had to co-occur in at least one node of T . Each edge in G comes from a clique for some vertex v in G , so the edge has both its endpoints in any node of T corresponding to a node of T that contained v. Thus T is a valid tree decomposition of G . We expand each node in the tree decomposition by at most the maximum degree of the graph \u2206(G ), and therefore tw(G ) \u2264 \u2206(G )tw(G )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "Assume that we have an efficient algorithm for computing the optimal parsing strategy of an arbitrary LCFRS rule. Consider the following algorithm for finding a tree decomposition of an input graph G:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "r Transform G to G of even degree, and construct LCFRS production P from an Eulerian tour of G .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "r Find the optimal parsing strategy for P. r Translate this strategy into a tree decomposition of G of treewidth k , and map this into a tree decomposition of G , and then remove all new nodes\u00ea to obtain a tree decomposition of G of treewidth SOL.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "If tw(G ) = k , we have SOL \u2264 2k from Equation 6, and k \u2264 \u2206(G )tw(G ) from Equation 7. Putting these together:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "SOL \u2264 2\u2206(G )tw(G )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "and using Equations (4) and (5) to relate our result to the original graph G, SOL \u2264 4\u2206(G)tw (G) This last inequality proves the main result of this section",
	"cite_spans": [
	{
	"start": 92,
	"end": 95,
	"text": "(G)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "An algorithm for finding the optimal parsing strategy of an arbitrary LCFRS production would imply a 4\u2206(G) approximation algorithm for treewidth.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 2",
	"sec_num": null
	},
	{
	"text": "Whether such an approximation algorithm for treewidth is possible is an open problem. The best-known result is the O( log k) approximation result of Feige, Hajiaghayi, and Lee (2005) , which improves on the O(log k) result of Amir (2001) . This indicates that, although polynomial-time factorization of LCFRS rules to optimize parsing complexity may be possible, it would require progress on general algorithms for treewidth.",
	"cite_spans": [
	{
	"start": 149,
	"end": 182,
	"text": "Feige, Hajiaghayi, and Lee (2005)",
	"ref_id": "BIBREF12"
	},
	{
	"start": 226,
	"end": 237,
	"text": "Amir (2001)",
	"ref_id": "BIBREF1"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 2",
	"sec_num": null
	},
	{
	"text": "We have demonstrated that a number of techniques used for specific parsing problems can be found algorithmically from declarative specifications of the grammar. Our method involves finding the optimal tree decomposition of a graph, which is in general an NP-complete problem. However, the relation to tree decomposition allows us to exploit existing algorithms for this problem, such as the linear time algorithm of Bodlaender (1996) for graphs of bounded treewidth. In practice, grammar rules are typically small, and finding the tree decomposition is not computationally expensive, and in fact is trivial in comparison to the original parsing problem. Given the special structure of the graphs derived from LCFRS productions, however, we have explored whether finding optimal tree decompositions of these graphs, and therefore optimal parsing strategies for LCFRS productions, is also NP-complete. Although a polynomial time algorithm for this problem would not necessarily imply that P = NP, it would require progress on fundamental, well-studied problems in graph theory. Therefore, it does not seem possible to exploit the special structure of graphs derived from LCFRS productions.",
	"cite_spans": [
	{
	"start": 416,
	"end": 433,
	"text": "Bodlaender (1996)",
	"ref_id": "BIBREF4"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusion",
	"sec_num": "5."
	}
	],
	"back_matter": [
	{
	"text": "This work was funded by NSF grants IIS-0546554 and IIS-0910611. We are grateful to Giorgio Satta for extensive discussions on grammar factorization, as well as for feedback on earlier drafts from Mehdi Hafezi Manshadi, Matt Post, and four anonymous reviewers.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Acknowledgments",
	"sec_num": null
	}
	],
	"bib_entries": {
	"BIBREF0": {
	"ref_id": "b0",
	"title": "The Theory of Parsing, Translation, and Compiling",
	"authors": [
	{
	"first": "Albert",
	"middle": [
	"V"
	],
	"last": "Aho",
	"suffix": ""
	},
	{
	"first": "Jeffery",
	"middle": [
	"D"
	],
	"last": "Ullman",
	"suffix": ""
	}
	],
	"year": 1972,
	"venue": "",
	"volume": "1",
	"issue": "",
	"pages": "",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Aho, Albert V. and Jeffery D. Ullman. 1972. The Theory of Parsing, Translation, and Compiling, volume 1. Prentice-Hall, Englewood Cliffs, NJ.",
	"links": null
	},
	"BIBREF1": {
	"ref_id": "b1",
	"title": "Efficient approximation for triangulation of minimum treewidth",
	"authors": [
	{
	"first": "Eyal",
	"middle": [],
	"last": "Amir",
	"suffix": ""
	}
	],
	"year": 2001,
	"venue": "17th Conference on Uncertainty in Artificial Intelligence",
	"volume": "",
	"issue": "",
	"pages": "7--15",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Amir, Eyal. 2001. Efficient approximation for triangulation of minimum treewidth. In 17th Conference on Uncertainty in Artificial Intelligence, pages 7-15, Seattle, WA.",
	"links": null
	},
	"BIBREF2": {
	"ref_id": "b2",
	"title": "Complexity of finding embeddings in a k-tree",
	"authors": [
	{
	"first": "",
	"middle": [],
	"last": "Arnborg",
	"suffix": ""
	},
	{
	"first": "Derek",
	"middle": [
	"G"
	],
	"last": "Stefen",
	"suffix": ""
	},
	{
	"first": "Andrzej",
	"middle": [],
	"last": "Corneil",
	"suffix": ""
	},
	{
	"first": "",
	"middle": [],
	"last": "Proskurowski",
	"suffix": ""
	}
	],
	"year": 1987,
	"venue": "SIAM Journal of Algebraic and Discrete Methods",
	"volume": "8",
	"issue": "",
	"pages": "277--284",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Arnborg, Stefen, Derek G. Corneil, and Andrzej Proskurowski. 1987. Complexity of finding embeddings in a k-tree. SIAM Journal of Algebraic and Discrete Methods, 8:277-284.",
	"links": null
	},
	"BIBREF3": {
	"ref_id": "b3",
	"title": "On formal properties of simple phrase structure grammars",
	"authors": [
	{
	"first": "",
	"middle": [],
	"last": "Bar-Hillel",
	"suffix": ""
	},
	{
	"first": "M",
	"middle": [],
	"last": "Yehoshua",
	"suffix": ""
	},
	{
	"first": "E",
	"middle": [],
	"last": "Perles",
	"suffix": ""
	},
	{
	"first": "",
	"middle": [],
	"last": "Shamir",
	"suffix": ""
	}
	],
	"year": 1961,
	"venue": "Language and Information: Selected Essays on Their Theory and Application",
	"volume": "14",
	"issue": "",
	"pages": "116--150",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Bar-Hillel, Yehoshua, M. Perles, and E. Shamir. 1961. On formal properties of simple phrase structure grammars. Zeitschrift f\u00fcr Phonetik, Sprachwissenschaft und Kommunikationsforschung, 14:143-172. Reprinted in Y. Bar-Hillel. (1964). Language and Information: Selected Essays on Their Theory and Application, Addison-Wesley Reading, MA, pages 116-150.",
	"links": null
	},
	"BIBREF4": {
	"ref_id": "b4",
	"title": "A linear time algorithm for finding tree decompositions of small treewidth",
	"authors": [
	{
	"first": "H",
	"middle": [
	"L"
	],
	"last": "Bodlaender",
	"suffix": ""
	}
	],
	"year": 1996,
	"venue": "SIAM Journal on Computing",
	"volume": "25",
	"issue": "",
	"pages": "1305--1317",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Bodlaender, H. L. 1996. A linear time algorithm for finding tree decompositions of small treewidth. SIAM Journal on Computing, 25:1305-1317.",
	"links": null
	},
	"BIBREF5": {
	"ref_id": "b5",
	"title": "Approximating treewidth, pathwidth, frontsize, and shortest elimination tree",
	"authors": [
	{
	"first": "Hans",
	"middle": [
	"L"
	],
	"last": "Bodlaender",
	"suffix": ""
	},
	{
	"first": "R",
	"middle": [],
	"last": "John",
	"suffix": ""
	},
	{
	"first": "",
	"middle": [],
	"last": "Gilbert",
	"suffix": ""
	}
	],
	"year": 1995,
	"venue": "Journal of Algorithms",
	"volume": "18",
	"issue": "2",
	"pages": "238--255",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Bodlaender, Hans L., John R. Gilbert, Hj\u00e1lmt\u00fdr Hafsteinsson, and Ton Kloks. 1995. Approximating treewidth, pathwidth, frontsize, and shortest elimination tree. Journal of Algorithms, 18(2):238-255.",
	"links": null
	},
	"BIBREF6": {
	"ref_id": "b6",
	"title": "Conjunctive query containment revisited",
	"authors": [
	{
	"first": "Chandra",
	"middle": [],
	"last": "Chekuri",
	"suffix": ""
	},
	{
	"first": "Anand",
	"middle": [],
	"last": "Rajaraman",
	"suffix": ""
	}
	],
	"year": 1997,
	"venue": "Database Theory -ICDT '97",
	"volume": "1186",
	"issue": "",
	"pages": "56--70",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Chekuri, Chandra and Anand Rajaraman. 1997. Conjunctive query containment revisited. In Database Theory -ICDT '97, volume 1186 of Lecture Notes in Computer Science. Springer, Berlin, pages 56-70.",
	"links": null
	},
	"BIBREF7": {
	"ref_id": "b7",
	"title": "Hierarchical phrase-based translation",
	"authors": [
	{
	"first": "David",
	"middle": [],
	"last": "Chiang",
	"suffix": ""
	}
	],
	"year": 2007,
	"venue": "Computational Linguistics",
	"volume": "33",
	"issue": "2",
	"pages": "201--228",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Chiang, David. 2007. Hierarchical phrase-based translation. Computational Linguistics, 33(2):201-228.",
	"links": null
	},
	"BIBREF8": {
	"ref_id": "b8",
	"title": "Tree clustering for constraint networks",
	"authors": [
	{
	"first": "Rina",
	"middle": [],
	"last": "Dechter",
	"suffix": ""
	},
	{
	"first": "Judea",
	"middle": [],
	"last": "Pearl",
	"suffix": ""
	}
	],
	"year": 1989,
	"venue": "Artificial Intelligence",
	"volume": "38",
	"issue": "3",
	"pages": "353--366",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Dechter, Rina and Judea Pearl. 1989. Tree clustering for constraint networks. Artificial Intelligence, 38(3):353-366.",
	"links": null
	},
	"BIBREF9": {
	"ref_id": "b9",
	"title": "Program transformations for optimization of parsing algorithms and other weighted logic programs",
	"authors": [
	{
	"first": "Jason",
	"middle": [],
	"last": "Eisner",
	"suffix": ""
	},
	{
	"first": "John",
	"middle": [],
	"last": "Blatz",
	"suffix": ""
	}
	],
	"year": 2007,
	"venue": "Proceedings of FG 2006: The 11th Conference on Formal Grammar. CSLI Publications",
	"volume": "",
	"issue": "",
	"pages": "45--85",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Eisner, Jason and John Blatz. 2007. Program transformations for optimization of parsing algorithms and other weighted logic programs. In Shuly Wintner, editor, Proceedings of FG 2006: The 11th Conference on Formal Grammar. CSLI Publications, pages 45-85, Malaga.",
	"links": null
	},
	"BIBREF10": {
	"ref_id": "b10",
	"title": "Efficient parsing for bilexical context-free grammars and head automaton grammars",
	"authors": [
	{
	"first": "Jason",
	"middle": [],
	"last": "Eisner",
	"suffix": ""
	},
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	}
	],
	"year": 1999,
	"venue": "Proceedings of the 37th Annual Conference of the Association for Computational Linguistics (ACL-99)",
	"volume": "",
	"issue": "",
	"pages": "457--464",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Eisner, Jason and Giorgio Satta. 1999. Efficient parsing for bilexical context-free grammars and head automaton grammars. In Proceedings of the 37th Annual Conference of the Association for Computational Linguistics (ACL-99), pages 457-464, College Park, MD.",
	"links": null
	},
	"BIBREF11": {
	"ref_id": "b11",
	"title": "A faster parsing algorithm for lexicalized tree-adjoining grammars",
	"authors": [
	{
	"first": "Jason",
	"middle": [],
	"last": "Eisner",
	"suffix": ""
	},
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "Proceedings of the 5th Workshop on Tree-Adjoining Grammars and Related Formalisms (TAG+5)",
	"volume": "",
	"issue": "",
	"pages": "14--19",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Eisner, Jason and Giorgio Satta. 2000. A faster parsing algorithm for lexicalized tree-adjoining grammars. In Proceedings of the 5th Workshop on Tree-Adjoining Grammars and Related Formalisms (TAG+5), pages 14-19, Paris.",
	"links": null
	},
	"BIBREF12": {
	"ref_id": "b12",
	"title": "Improved approximation algorithms for minimum-weight vertex separators",
	"authors": [
	{
	"first": "Uriel",
	"middle": [],
	"last": "Feige",
	"suffix": ""
	},
	{
	"first": "Mohammadtaghi",
	"middle": [],
	"last": "Hajiaghayi",
	"suffix": ""
	},
	{
	"first": "James",
	"middle": [
	"R"
	],
	"last": "Lee",
	"suffix": ""
	}
	],
	"year": 2005,
	"venue": "STOC '05: Proceedings of the thirty-seventh annual ACM symposium on Theory of computing",
	"volume": "",
	"issue": "",
	"pages": "563--572",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Feige, Uriel, MohammadTaghi Hajiaghayi, and James R. Lee. 2005. Improved approximation algorithms for minimum-weight vertex separators. In STOC '05: Proceedings of the thirty-seventh annual ACM symposium on Theory of computing, pages 563-572, Baltimore, MD.",
	"links": null
	},
	"BIBREF13": {
	"ref_id": "b13",
	"title": "Query evaluation via tree-decompositions",
	"authors": [
	{
	"first": "J\u00f6rg",
	"middle": [],
	"last": "Flum",
	"suffix": ""
	},
	{
	"first": "Markus",
	"middle": [],
	"last": "Frick",
	"suffix": ""
	},
	{
	"first": "Martin",
	"middle": [],
	"last": "Grohe",
	"suffix": ""
	}
	],
	"year": 2002,
	"venue": "Journal of the ACM",
	"volume": "49",
	"issue": "6",
	"pages": "716--752",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Flum, J\u00f6rg, Markus Frick, and Martin Grohe. 2002. Query evaluation via tree-decompositions. Journal of the ACM, 49(6):716-752.",
	"links": null
	},
	"BIBREF14": {
	"ref_id": "b14",
	"title": "Optimal parsing strategies for Linear Context-Free Rewriting Systems",
	"authors": [
	{
	"first": "Michel",
	"middle": [],
	"last": "Galley",
	"suffix": ""
	},
	{
	"first": "Mark",
	"middle": [],
	"last": "Hopkins",
	"suffix": ""
	},
	{
	"first": "Kevin",
	"middle": [],
	"last": "Knight",
	"suffix": ""
	},
	{
	"first": "Daniel",
	"middle": [],
	"last": "Marcu",
	"suffix": ""
	}
	],
	"year": 2004,
	"venue": "Proceedings of the 2004 Meeting of the North American Chapter of the Association for Computational Linguistics (NAACL-04)",
	"volume": "",
	"issue": "",
	"pages": "769--776",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Galley, Michel, Mark Hopkins, Kevin Knight, and Daniel Marcu. 2004. What's in a translation rule? In Proceedings of the 2004 Meeting of the North American Chapter of the Association for Computational Linguistics (NAACL-04), pages 273-280, Boston, MA. Gildea, Daniel. 2010. Optimal parsing strategies for Linear Context-Free Rewriting Systems. In Proceedings of the 2010 Meeting of the North American Chapter of the Association for Computational Linguistics (NAACL-10), pages 769-776, Los Angeles, CA.",
	"links": null
	},
	"BIBREF15": {
	"ref_id": "b15",
	"title": "Optimal reduction of rule length in Linear Context-Free Rewriting Systems",
	"authors": [
	{
	"first": "Daniel",
	"middle": [],
	"last": "Gildea",
	"suffix": ""
	},
	{
	"first": "Daniel\u0161tefankovi\u010d",
	"middle": [
	";"
	],
	"last": "G\u00f3mez-Rodr\u00edguez",
	"suffix": ""
	},
	{
	"first": "Carlos",
	"middle": [],
	"last": "",
	"suffix": ""
	},
	{
	"first": "Marco",
	"middle": [],
	"last": "Kuhlmann",
	"suffix": ""
	},
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	},
	{
	"first": "David",
	"middle": [],
	"last": "Weir",
	"suffix": ""
	}
	],
	"year": 2007,
	"venue": "Proceedings of the 2007 Meeting of the North American Chapter of the Association for Computational Linguistics (NAACL-07)",
	"volume": "",
	"issue": "",
	"pages": "539--547",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Gildea, Daniel and Daniel\u0160tefankovi\u010d. 2007. Worst-case synchronous grammar rules. In Proceedings of the 2007 Meeting of the North American Chapter of the Association for Computational Linguistics (NAACL-07), pages 147-154, Rochester, NY. G\u00f3mez-Rodr\u00edguez, Carlos, Marco Kuhlmann, Giorgio Satta, and David Weir. 2009. Optimal reduction of rule length in Linear Context-Free Rewriting Systems. In Proceedings of the 2009 Meeting of the North American Chapter of the Association for Computational Linguistics (NAACL-09), pages 539-547, Boulder, CO.",
	"links": null
	},
	"BIBREF16": {
	"ref_id": "b16",
	"title": "Semiring parsing. Computational Linguistics",
	"authors": [
	{
	"first": "Joshua",
	"middle": [],
	"last": "Goodman",
	"suffix": ""
	}
	],
	"year": 1999,
	"venue": "",
	"volume": "25",
	"issue": "",
	"pages": "573--605",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Goodman, Joshua. 1999. Semiring parsing. Computational Linguistics, 25(4):573-605.",
	"links": null
	},
	"BIBREF17": {
	"ref_id": "b17",
	"title": "Machine translation as lexicalized parsing with hooks",
	"authors": [
	{
	"first": "Liang",
	"middle": [],
	"last": "Huang",
	"suffix": ""
	},
	{
	"first": "Hao",
	"middle": [],
	"last": "Zhang",
	"suffix": ""
	},
	{
	"first": "Daniel",
	"middle": [],
	"last": "Gildea",
	"suffix": ""
	}
	],
	"year": 2005,
	"venue": "International Workshop on Parsing Technologies (IWPT05)",
	"volume": "",
	"issue": "",
	"pages": "65--73",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Huang, Liang, Hao Zhang, and Daniel Gildea. 2005. Machine translation as lexicalized parsing with hooks. In International Workshop on Parsing Technologies (IWPT05), pages 65-73, Vancouver.",
	"links": null
	},
	"BIBREF18": {
	"ref_id": "b18",
	"title": "Binarization of synchronous context-free grammars",
	"authors": [
	{
	"first": "Liang",
	"middle": [],
	"last": "Huang",
	"suffix": ""
	},
	{
	"first": "Hao",
	"middle": [],
	"last": "Zhang",
	"suffix": ""
	},
	{
	"first": "Daniel",
	"middle": [],
	"last": "Gildea",
	"suffix": ""
	},
	{
	"first": "Kevin",
	"middle": [],
	"last": "Knight",
	"suffix": ""
	}
	],
	"year": 2009,
	"venue": "Computational Linguistics",
	"volume": "35",
	"issue": "4",
	"pages": "559--595",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Huang, Liang, Hao Zhang, Daniel Gildea, and Kevin Knight. 2009. Binarization of synchronous context-free grammars. Computational Linguistics, 35(4):559-595.",
	"links": null
	},
	"BIBREF19": {
	"ref_id": "b19",
	"title": "Bayesian updating in causal probabilistic networks by local computations",
	"authors": [
	{
	"first": "Finn",
	"middle": [
	"V"
	],
	"last": "Jensen",
	"suffix": ""
	},
	{
	"first": "L",
	"middle": [],
	"last": "Steffen",
	"suffix": ""
	},
	{
	"first": "Kristian",
	"middle": [
	"G"
	],
	"last": "Lauritzen",
	"suffix": ""
	},
	{
	"first": "",
	"middle": [],
	"last": "Olesen",
	"suffix": ""
	}
	],
	"year": 1990,
	"venue": "Computational Statistics Quarterly",
	"volume": "4",
	"issue": "",
	"pages": "269--282",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Jensen, Finn V., Steffen L. Lauritzen, and Kristian G. Olesen. 1990. Bayesian updating in causal probabilistic networks by local computations. Computational Statistics Quarterly, 4:269-282.",
	"links": null
	},
	"BIBREF20": {
	"ref_id": "b20",
	"title": "Transforming projective bilexical dependency grammars into efficiently-parsable CFGs with unfold-fold",
	"authors": [
	{
	"first": "Mark",
	"middle": [],
	"last": "Johnson",
	"suffix": ""
	}
	],
	"year": 2007,
	"venue": "Proceedings of the 45th Annual Meeting of the Association of Computational Linguistics",
	"volume": "",
	"issue": "",
	"pages": "168--175",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Johnson, Mark. 2007. Transforming projective bilexical dependency grammars into efficiently-parsable CFGs with unfold-fold. In Proceedings of the 45th Annual Meeting of the Association of Computational Linguistics, pages 168-175, Prague.",
	"links": null
	},
	"BIBREF21": {
	"ref_id": "b21",
	"title": "A generalization of Dijkstra's algorithm",
	"authors": [
	{
	"first": "D",
	"middle": [],
	"last": "Knuth",
	"suffix": ""
	}
	],
	"year": 1977,
	"venue": "Information Processing Letters",
	"volume": "6",
	"issue": "1",
	"pages": "1--5",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Knuth, D. 1977. A generalization of Dijkstra's algorithm. Information Processing Letters, 6(1):1-5.",
	"links": null
	},
	"BIBREF22": {
	"ref_id": "b22",
	"title": "Factor graphs and the sum-product algorithm",
	"authors": [
	{
	"first": "F",
	"middle": [
	"R"
	],
	"last": "Kschischang",
	"suffix": ""
	},
	{
	"first": "B",
	"middle": [
	"J"
	],
	"last": "Frey",
	"suffix": ""
	},
	{
	"first": "H",
	"middle": [
	"A"
	],
	"last": "Loeliger",
	"suffix": ""
	}
	],
	"year": 2001,
	"venue": "IEEE Transactions on Information Theory",
	"volume": "47",
	"issue": "2",
	"pages": "498--519",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kschischang, F. R., B. J. Frey, and H. A. Loeliger. 2001. Factor graphs and the sum-product algorithm. IEEE Transactions on Information Theory, 47(2):498-519.",
	"links": null
	},
	"BIBREF23": {
	"ref_id": "b23",
	"title": "Mildly non-projective dependency structures",
	"authors": [
	{
	"first": "Marco",
	"middle": [],
	"last": "Kuhlmann",
	"suffix": ""
	},
	{
	"first": "Joakim",
	"middle": [],
	"last": "Nivre",
	"suffix": ""
	}
	],
	"year": 2006,
	"venue": "Proceedings of the International Conference on Computational Linguistics/Association for Computational Linguistics (COLING/ACL-06)",
	"volume": "",
	"issue": "",
	"pages": "507--514",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kuhlmann, Marco and Joakim Nivre. 2006. Mildly non-projective dependency structures. In Proceedings of the International Conference on Computational Linguistics/Association for Computational Linguistics (COLING/ACL-06), pages 507-514, Sydney.",
	"links": null
	},
	"BIBREF24": {
	"ref_id": "b24",
	"title": "Treebank grammar techniques for non-projective dependency parsing",
	"authors": [
	{
	"first": "Marco",
	"middle": [],
	"last": "Kuhlmann",
	"suffix": ""
	},
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	}
	],
	"year": 2009,
	"venue": "Proceedings of the 12th Conference of the European Chapter of the ACL (EACL-09)",
	"volume": "",
	"issue": "",
	"pages": "478--486",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kuhlmann, Marco and Giorgio Satta. 2009. Treebank grammar techniques for non-projective dependency parsing. In Proceedings of the 12th Conference of the European Chapter of the ACL (EACL-09), pages 478-486, Athens.",
	"links": null
	},
	"BIBREF25": {
	"ref_id": "b25",
	"title": "On the complexity analysis of static analyses",
	"authors": [
	{
	"first": "David",
	"middle": [],
	"last": "Mcallester",
	"suffix": ""
	}
	],
	"year": 2002,
	"venue": "Journal of the ACM",
	"volume": "49",
	"issue": "4",
	"pages": "512--537",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "McAllester, David. 2002. On the complexity analysis of static analyses. Journal of the ACM, 49(4):512-537.",
	"links": null
	},
	"BIBREF26": {
	"ref_id": "b26",
	"title": "Generalized multitext grammars",
	"authors": [
	{
	"first": "I",
	"middle": [],
	"last": "Melamed",
	"suffix": ""
	},
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Dan",
	"suffix": ""
	},
	{
	"first": "Ben",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	},
	{
	"first": "",
	"middle": [],
	"last": "Wellington",
	"suffix": ""
	}
	],
	"year": 2004,
	"venue": "Proceedings of the 42nd",
	"volume": "",
	"issue": "",
	"pages": "",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Melamed, I. Dan, Giorgio Satta, and Ben Wellington. 2004. Generalized multitext grammars. In Proceedings of the 42nd",
	"links": null
	},
	"BIBREF27": {
	"ref_id": "b27",
	"title": "Annual Conference of the Association for Computational Linguistics (ACL-04)",
	"authors": [],
	"year": null,
	"venue": "",
	"volume": "",
	"issue": "",
	"pages": "661--668",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Annual Conference of the Association for Computational Linguistics (ACL-04), pages 661-668, Barcelona.",
	"links": null
	},
	"BIBREF28": {
	"ref_id": "b28",
	"title": "Weighted deductive parsing and Knuth's algorithm",
	"authors": [
	{
	"first": "M.-J",
	"middle": [],
	"last": "Nederhof",
	"suffix": ""
	}
	],
	"year": 2003,
	"venue": "Computational Linguistics",
	"volume": "29",
	"issue": "1",
	"pages": "135--144",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Nederhof, M.-J. 2003. Weighted deductive parsing and Knuth's algorithm. Computational Linguistics, 29(1):135-144.",
	"links": null
	},
	"BIBREF29": {
	"ref_id": "b29",
	"title": "Independent parallelism in finite copying parallel rewriting systems",
	"authors": [
	{
	"first": "Owen",
	"middle": [],
	"last": "Rambow",
	"suffix": ""
	},
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	}
	],
	"year": 1999,
	"venue": "Theoretical Computer Science",
	"volume": "223",
	"issue": "1-2",
	"pages": "87--120",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Rambow, Owen and Giorgio Satta. 1999. Independent parallelism in finite copying parallel rewriting systems. Theoretical Computer Science, 223(1-2):87-120.",
	"links": null
	},
	"BIBREF30": {
	"ref_id": "b30",
	"title": "Recognition of Linear Context-Free Rewriting Systems",
	"authors": [
	{
	"first": "Giorgio",
	"middle": [],
	"last": "Satta",
	"suffix": ""
	}
	],
	"year": 1992,
	"venue": "Proceedings of the 30th Annual Conference of the Association for Computational Linguistics (ACL-92)",
	"volume": "",
	"issue": "",
	"pages": "89--95",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Satta, Giorgio. 1992. Recognition of Linear Context-Free Rewriting Systems. In Proceedings of the 30th Annual Conference of the Association for Computational Linguistics (ACL-92), pages 89-95, Newark, DE.",
	"links": null
	},
	"BIBREF31": {
	"ref_id": "b31",
	"title": "Probability propagation",
	"authors": [
	{
	"first": "G",
	"middle": [],
	"last": "Shafer",
	"suffix": ""
	},
	{
	"first": "P",
	"middle": [],
	"last": "Shenoy",
	"suffix": ""
	}
	],
	"year": 1990,
	"venue": "Annals of Mathematics and Artificial Intelligence",
	"volume": "2",
	"issue": "",
	"pages": "327--353",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Shafer, G. and P. Shenoy. 1990. Probability propagation. Annals of Mathematics and Artificial Intelligence, 2:327-353.",
	"links": null
	},
	"BIBREF32": {
	"ref_id": "b32",
	"title": "Principles and implementation of deductive parsing",
	"authors": [
	{
	"first": "Stuart",
	"middle": [
	"M"
	],
	"last": "Shieber",
	"suffix": ""
	},
	{
	"first": "Yves",
	"middle": [],
	"last": "Schabes",
	"suffix": ""
	},
	{
	"first": "Fernando",
	"middle": [
	"C N"
	],
	"last": "Pereira",
	"suffix": ""
	}
	],
	"year": 1995,
	"venue": "The Journal of Logic Programming",
	"volume": "24",
	"issue": "1-2",
	"pages": "3--36",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Shieber, Stuart M., Yves Schabes, and Fernando C. N. Pereira. 1995. Principles and implementation of deductive parsing. The Journal of Logic Programming, 24(1-2):3-36.",
	"links": null
	},
	"BIBREF33": {
	"ref_id": "b33",
	"title": "Characterizing structural descriptions produced by various grammatical formalisms",
	"authors": [
	{
	"first": "K",
	"middle": [],
	"last": "Vijay-Shankar",
	"suffix": ""
	},
	{
	"first": "D",
	"middle": [
	"L"
	],
	"last": "Weir",
	"suffix": ""
	},
	{
	"first": "A",
	"middle": [
	"K"
	],
	"last": "Joshi",
	"suffix": ""
	}
	],
	"year": 1987,
	"venue": "Proceedings of the International Conference on Computational Linguistics/Association for Computational Linguistics (COLING/ACL-06)",
	"volume": "",
	"issue": "",
	"pages": "977--984",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Vijay-Shankar, K., D. L. Weir, and A. K. Joshi. 1987. Characterizing structural descriptions produced by various grammatical formalisms. In Proceedings of the 25th Annual Conference of the Association for Computational Linguistics (ACL-87), pages 104-111, Stanford, CA. Wellington, Benjamin, Sonjia Waxmonsky, and I. Dan Melamed. 2006. Empirical lower bounds on the complexity of translational equivalence. In Proceedings of the International Conference on Computational Linguistics/Association for Computational Linguistics (COLING/ACL-06), pages 977-984, Sydney.",
	"links": null
	},
	"BIBREF34": {
	"ref_id": "b34",
	"title": "Stochastic inversion transduction grammars and bilingual parsing of parallel corpora",
	"authors": [
	{
	"first": "Dekai",
	"middle": [],
	"last": "Wu",
	"suffix": ""
	}
	],
	"year": 1997,
	"venue": "Computational Linguistics",
	"volume": "23",
	"issue": "3",
	"pages": "377--403",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Wu, Dekai. 1997. Stochastic inversion transduction grammars and bilingual parsing of parallel corpora. Computational Linguistics, 23(3):377-403.",
	"links": null
	},
	"BIBREF35": {
	"ref_id": "b35",
	"title": "Factorization of synchronous context-free grammars in linear time",
	"authors": [
	{
	"first": "Hao",
	"middle": [],
	"last": "Zhang",
	"suffix": ""
	},
	{
	"first": "Daniel",
	"middle": [],
	"last": "Gildea",
	"suffix": ""
	}
	],
	"year": 2007,
	"venue": "NAACL Workshop on Syntax and Structure in Statistical Translation (SSST)",
	"volume": "",
	"issue": "",
	"pages": "25--32",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Zhang, Hao and Daniel Gildea. 2007. Factorization of synchronous context-free grammars in linear time. In NAACL Workshop on Syntax and Structure in Statistical Translation (SSST), pages 25-32, Rochester, NY.",
	"links": null
	}
	},
	"ref_entries": {
	"FIGREF0": {
	"uris": null,
	"type_str": "figure",
	"text": "CFG parsing in weighted deduction notation.",
	"num": null
	},
	"FIGREF1": {
	"uris": null,
	"type_str": "figure",
	"text": "Rule factorization for bilexicalized parsing.",
	"num": null
	},
	"FIGREF2": {
	"uris": null,
	"type_str": "figure",
	"text": "Figure 4 A tree decomposition of a graph is a set of overlapping clusters of the graph's vertices, arranged in a tree. This example has treewidth = 2.",
	"num": null
	},
	"FIGREF3": {
	"uris": null,
	"type_str": "figure",
	"text": "Factor graph for the binary CFG deduction rule ofFigure 1.",
	"num": null
	},
	"FIGREF4": {
	"uris": null,
	"type_str": "figure",
	"text": "Treewidth applied to the SCFG rule of Equation (2).",
	"num": null
	}
	}
	}
	}