{ "paper_id": "U04-1011", "header": { "generated_with": "S2ORC 1.0.0", "date_generated": "2023-01-19T03:08:05.004974Z" }, "title": "A Meta-grammar for CCG", "authors": [ { "first": "Mark", "middle": [], "last": "Foreman", "suffix": "", "affiliation": { "laboratory": "", "institution": "The University of Adelaide Adelaide SA", "location": { "postCode": "5005" } }, "email": "mark.foreman@csiro.au" }, { "first": "Daniel", "middle": [], "last": "Mcmichael", "suffix": "", "affiliation": {}, "email": "daniel.mcmichael@csiro.au" } ], "year": "", "venue": null, "identifiers": {}, "abstract": "Applying CCG to domains outside of linguistics could require different sets of combinators to be developed for each domain. The meta-grammar described in this paper aims to assist such development by enabling simple, succinct expression of both existing and new combinator definitions. It favours the development of an easily-configurable, onetime-coded module that can perform CCG combinations for any combinator set of the researcher's choosing. A preliminary implementation shows both the feasibility and potential of the meta-grammar.", "pdf_parse": { "paper_id": "U04-1011", "_pdf_hash": "", "abstract": [ { "text": "Applying CCG to domains outside of linguistics could require different sets of combinators to be developed for each domain. The meta-grammar described in this paper aims to assist such development by enabling simple, succinct expression of both existing and new combinator definitions. It favours the development of an easily-configurable, onetime-coded module that can perform CCG combinations for any combinator set of the researcher's choosing. A preliminary implementation shows both the feasibility and potential of the meta-grammar.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Abstract", "sec_num": null } ], "body_text": [ { "text": "The merits of Combinatory Categorial Grammar (CCG) have been established via natural language parser implementations like that of Hockenmaier and Steedman (2002) and Clark and Curran (2004) . But recent findings show that categorial grammars based on CCG also display promise in domains outside of linguistics (McMichael et al., 2004) . Over the years, new combinators have been developed to extend the system of pure categorial grammar (Steedman 2003) , but although the set of combinators for CCG seems to have stabilised, this same set may not necessarily be applicable to analyses in other domains. In fact, McMichael et al. introduce two combinatorsfunctional application and modificational application, both defined in section 2.1 -that are not part of the existing set of CCG combinators. Additionally, functional application cannot even be cleanly defined via a traditional combinator pattern. It is partly this inability of the existing techniques to cleanly define new combinators that motivates the proposal of a meta-grammar for combinator specification.", "cite_spans": [ { "start": 130, "end": 161, "text": "Hockenmaier and Steedman (2002)", "ref_id": null }, { "start": 166, "end": 189, "text": "Clark and Curran (2004)", "ref_id": "BIBREF3" }, { "start": 310, "end": 334, "text": "(McMichael et al., 2004)", "ref_id": "BIBREF13" }, { "start": 437, "end": 452, "text": "(Steedman 2003)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "In this paper, we explain the motivations for and give a specification of the meta-grammar, along with complete examples of how it applies to new and existing combinators. Lastly, we examine the workings and potential of a preliminary implementation. The remainder of this section, however, presents a brief introduction to CCG.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "CCG operates by first assigning a syntactic category to each word in the sentence, as will be demonstrated in the proceeding example borrowed from Hockenmaier (2003) . At this point, the notation for describing categories should be observed.", "cite_spans": [ { "start": 147, "end": 165, "text": "Hockenmaier (2003)", "ref_id": "BIBREF7" } ], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "Assuming the simplistic subject-verb-object (SVO) pattern for English, the phrase \"buys shares\" will form a complete sentence S if it is preceded by a noun phrase, and we write this as:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "buys shares \u251c S\\NP So the phrase \"buys shares\" can be thought of as a function that takes a noun phrase NP as an argument to its left and returns a sentence S.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "Furthermore, \"buys\" will form a S\\NP if it is followed by a noun phrase, and this is denoted as:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "buys \u251c (S\\NP)/NP", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "In doing this, we have eliminated the need for a separate verb category V, leaving us with the following category assignments:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "John \u251c NP buys \u251c (S\\NP)/NP shares \u251c NP", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "Formally, a category may be either atomic (S, NP, etc) or complex (S\\S, (S\\NP)/NP), etc). Complex categories take the general form \u03b1/\u03b2 or \u03b1\\\u03b2, where \u03b1 and \u03b2 are themselves categories.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "Given the above category assignments, a derivation proceeds as follows: \"buys\" is combined with \"shares\" under the operation of forward application (the term forward referring to both the direction of the slash). The phrase \"buys shares\" is combined with \"John\" under the operation of backward application.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "The combinators (operators) that govern these two operations are defined as follows:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "X/Y Y \u21d2 > X Y X\\Y \u21d2 < X", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "where X and Y represent any category. Typically, a derivation is represented in the following manner:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "John NP buys (S\\NP)/NP shares NP > S\\NP < S", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "which corresponds to the following tree: Several other combinators are defined by Steedman (2000) for capturing long-range dependencies in the English and Dutch languages: coordination (\u0424) type-raising (T), composition (B) and substitution (S). These combinator families are listed below:", "cite_spans": [ { "start": 82, "end": 97, "text": "Steedman (2000)", "ref_id": "BIBREF16" } ], "ref_spans": [], "eq_spans": [], "section": "A Practical Introduction to CCG", "sec_num": "1.1" }, { "text": "X conj X \u21d2 <\u0424> X X \u21d2 >T Y/(Y\\X) X \u21d2 B X/Z X/Y Y\\Z \u21d2 >Bx X\\Z Y\\Z X\\Y \u21d2 S X/Z (X/Y)\\Z Y\\Z \u21d2 >Sx X\\Z Y\\Z (X\\Y)\\Z \u21d2 B, >Bx, B, along with the transformations required to obtain the variations >Bx, F X Y X\\Y \u21d2 M X X X\\X \u21d2 F and >M together cover all combinations possible under the traditional vanilla forward application rule >; similarly for F and and < combinators if it were not for the caveat. So this example not only demonstrates new combinators, but also highlights the shortcomings of the current methods for specifying combinators. The proposed metagrammar provides an elegant (caveat-free) solution to this problem.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "New Domains", "sec_num": "2.1" }, { "text": "Another domain that is planned for investigation is geology. The general intent is to analyse vertical sequences of discrete sedimentary layers in a manner analogous to English parsing, where sequences of (discrete) words are analysed. Griffiths (1989) founded the precursor to this research by demonstrating that meaningful analyses could be performed on sedimentary sequences using a context-free grammar. He also speculated that context-sensitive analyses might be able to resolve some ambiguities, lending weight to the application of CCG, which is mildly contextsensitive, to such a task.", "cite_spans": [ { "start": 236, "end": 252, "text": "Griffiths (1989)", "ref_id": "BIBREF6" } ], "ref_spans": [], "eq_spans": [], "section": "New Domains", "sec_num": "2.1" }, { "text": "When employing a statistical parser, a suitable corpus of pre-parsed sentences is required for training the probabilities. However, altering the grammar through the addition or deletion of combinators (as is done when applying CCG to new domains) requires a new corpus to be markedup accordingly. This process typically requires converting the context-free derivation trees from the Penn Treebank (Marcus et al., 1993 (Marcus et al., , 1994 to intermediate binary context-free trees and then finally to CCG trees. The second stage of conversion (binary CF to CCG) requires a technique referred to as inverse combination, where an unknown left or right category is determined given the result category. This contrasts to regular combination, where the unknown result is deduced from two known operands. There are two types of inverse combination: missing-left (when the right operand and result are known) and missing-right (when the left operand and result are known. Missing-left and missing-right scenarios are shown left and right respectively below.", "cite_spans": [ { "start": 397, "end": 417, "text": "(Marcus et al., 1993", "ref_id": "BIBREF12" }, { "start": 418, "end": 440, "text": "(Marcus et al., , 1994", "ref_id": "BIBREF11" } ], "ref_spans": [], "eq_spans": [], "section": "Converting Treebanks", "sec_num": "2.2" }, { "text": "C result C right C left C result", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Converting Treebanks", "sec_num": "2.2" }, { "text": "It will be shown in section 4.2 that a standard implementation of the meta-grammar can be made to perform these operations by merely permuting some of the configuration information passed to the module.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Converting Treebanks", "sec_num": "2.2" }, { "text": "The implementation described in this paper was coded in Python (Python Programming Language, 2004) . Python was chosen for its ability to aid rapid prototyping and for its ease of integration with much faster C code. Thus we hope to benefit from lower coding times and easier debugging, with the option to port to C and re-integrate any mature code that is deemed time-critical.", "cite_spans": [ { "start": 83, "end": 98, "text": "Language, 2004)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Python Implementation", "sec_num": "2.3" }, { "text": "This section details the meta-grammar that controls the specification of a CCG. The set of combinators are specified as a list of combinator templates, one template for each combinator family:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The Meta-grammar", "sec_num": "3" }, { "text": "COMBINATOR-SET := COMBINATOR-TEMPLATE 1 \u2026 \u2026 COMBINATOR-TEMPLATE m", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The Meta-grammar", "sec_num": "3" }, { "text": "Each combinator template defined separately, as well as any atomic variations referenced in the templates. These are both described below, and proceeded by some example templates.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The Meta-grammar", "sec_num": "3" }, { "text": "It is worth noting that this proposal focuses primarily on specifying combinators for the express purpose of performing combinations. The corresponding semantics (logical forms) may be associated with operands and the result, following from Steedman (2000) .", "cite_spans": [ { "start": 241, "end": 256, "text": "Steedman (2000)", "ref_id": "BIBREF16" } ], "ref_spans": [], "eq_spans": [], "section": "The Meta-grammar", "sec_num": "3" }, { "text": "A combinator template is specified as a tuple:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Combinator Template", "sec_num": "3.1" }, { "text": "COMBINATOR-TEMPLATE := ( TYPE, OPERAND-PATTERN-LIST, RESULT-PATTERN, PERMITTED-VARIATIONS )", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Combinator Template", "sec_num": "3.1" }, { "text": "where the entries in the tuple are defined as: TYPE: an identifier for the combinator that should be unique across all other combinator templates. Typically it is a single character; in section 1.1 we saw them as \u0424, T, B and S.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Combinator Template", "sec_num": "3.1" }, { "text": "OPERAND-PATTERN-LIST: the ordered list of n operand patterns. Typically n=2 since most combinators are binary operations, although n=1 for type-raising (T). The syntax for these patterns is given in section 3.2.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Combinator Template", "sec_num": "3.1" }, { "text": "RESULT-PATTERN: a pattern that specifies how to construct the resulting category from operand categories that successfully match the operand patterns. PERMITTED-VARIATIONS: as mentioned in section 2, only one pattern set is specified per family of combinators. Each variation in the family is specified as a tersely coded entry in this list. For instance, the composition family (B) would have permitted-variations = { >, >x, <, := | := ['e'|'n'] := ('A'|\u2026|'Z')+ := ('0'|\u2026|'9')+ := (|'['']') := | '('')' := := ('\\'|'/') For simplicity of expression, we introduce the semantic requirement that an n pattern may only occur immediately after a slash. Alternatively, we could provide a completely contextfree grammar for patterns through a slightly less intuitive EBNF, by redefining and : := ['e'] := (|'n')", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "Some patterns that conform to this syntax include:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "X 1 Y 1 / 2 Y 3 (X 1 / 1 Y 1 )\\ 2 X 2", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "Atomic patterns (patterns without slashes or brackets) are specified as alphanumeric strings which to allows for greater control over pattern specification. Any two atomic patterns (A'N' and A\"N\") and the categories they match (C' and C\" respectively) are governed by the following constraints:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "A\u2032=A\u2033, N\u2032=N\u2033 \u21d2 C\u2032=C\u2033 A\u2032=A\u2033, N\u2032\u2260N\u2033 \u21d2 C\u2032\u2260C\u2033 As an example, suppose we want to match some category to the pattern ((X 1 / 1 X 1 )/ 2 X 2 )/ 3 Y 1 , then the subcategory in the position of the first X 1 must be equal to the subcategory in the position of the second X 1 , but must be distinct from the subcategory in the position of the X 2 (and any other X that might have been in the pattern). The subcategories in the positions of X 1 , X 1 and X 2 are independent of the subcategory in the position of Y 1 . For example, this pattern would match the categories ((A/A)/B)/A, ((A/A)/B)/B and ((A/A)/B)/C, but not ((A/C)/B)/A or ((A/A)/A)/A.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "The presence of an 'e' in an atomic pattern indicates that the atomic pattern will only match with an atomic category. Thus X e 1 will match category A, but not A/A.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "The presence of an 'n' in an atomic pattern indicates that the atomic pattern will allow matching to an unlimited number of arguments, similar to the \"$ convention\" described in (Steedman 2000) . A pattern X 1 / 1 Y n 1 would match categories A/B, (A/B)/C, ((A/B)/C)/D, etc.", "cite_spans": [ { "start": 178, "end": 193, "text": "(Steedman 2000)", "ref_id": "BIBREF16" } ], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "Square brackets (if present) in a pattern surround an optional portion of that pattern. For example, the pattern X e 1 [/ 1 Y e 1 ] would match categories A and A/B, but not (A/B)/C or A/(B/C).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying a Pattern", "sec_num": "3.2" }, { "text": "Each combinator in a given family corresponds to exactly one variation in the permitted-variations list of that family's combinator-template. Suppose we have operand and result patterns:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "TYPE = B OPERANDS = X 1 / 1 Y 1 , Y 1 / 2 Z 1 RESULT = X 1 / 3 Z 1", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "then a > in the permitted-variations list corresponds to the combinator:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "X 1 /Y 1 Y 1 /Z 1 \u21d2 >B X 1 /Z 1", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "That is, forward combination > does not alter slash directions or operand order. On the other hand, backward combination < reverses all slashes and operand order, so a < in the permitted-variations list would correspond to the combinator:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "Y 1 \\Z 1 X 1 \\Y 1 \u21d2 . An atomic variation that is used in generating the composition (B) family is:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "x:{/ 2 ,/ 3 }", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Specifying Variations", "sec_num": "3.3" }, { "text": "That is, the x variant reverses the direction of slash 2 and slash 3. The effect of atomic variations is successive. So a variation like ,<} X 1 \u21d2 >T Y 1 /(Y 1 \\X 1 ) X 1 \u21d2 ,>x,<,B X 1 /Z n 1 X 1 /Y 1 Y 1 \\Z n 1 \u21d2 >Bx X 1 \\Z n 1 Y 1 \\Z n 1 X 1 \\Y 1 \u21d2 ,<} X 1 /X 2 X 2 \u21d2 >F X 1 X 2 X 1 \\X 2 \u21d2 >F X 1 3.4.4 Modificational Application TYPE = M OPERANDS = X 1 / 1 X 1 , X 1 RESULT = X 1 VARIATIONS = {>,<} X 1 /X 1 X 1 \u21d2 >F X 1 X 1 X 1 \\X 1 \u21d2 >F X 1", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Composition", "sec_num": "3.4.2" }, { "text": "4 Using the Implementation A prototype module has been developed in Python to implement the meta-grammar described in this paper. The module can be thought of as a factory which takes a combinator-set conforming to the definition in section 3 and returns a single function, combine().", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Composition", "sec_num": "3.4.2" }, { "text": "The combine() function takes any number of operand categories as arguments and returns a list of (result-category, combinator) tuples that corresponds to all possible categories that can be derived from the input categories.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "COMBINE FACTORY combinator templates combine() function fn", "sec_num": null }, { "text": "As an example, let us consider the module when configured by the type-raising and composition combinator templates given in sections 3.1 and 3.2. The input to the combine() function is a sequence of operand categories, and the output is a list of possible resulting categories and their corresponding combinators.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Combination", "sec_num": "4.1" }, { "text": "Suppose the input is a pair of categories, A/B and B\\C. Type-raising is immediately discounted by the function because it is unary and thus cannot operate on a pair of categories. Consequently, the function only considers the composition (B) combinators. The function attempts to match the first category, A/B, with the first operand pattern, X 1 / 1 Y 1 , and the second category, B\\C, with the second operand pattern, Y 1 / 2 Z n 1 , ignoring slash directions for the moment. This match is successful, and results in a match dictionary of {X 1 :A, Y 1 :B, Z n 1 :C}. The slashes are then found to match those required for forward crossing (>x) composition {s 1 :/, s 2 :\\}, but not for vanilla forward composition {s 1 :/, s 2 :/}. From these matches, the result can be built: X 1 \\Z n 1 :A\\C. To attempt the backwards combinations, the function then tries to match the input categories to the reversed sequence of operand patterns, i.e. A/B with Y 1 / 2 Z n 1 and B\\C with X 1 / 1 Y 1 . This attempt fails because Y 1 =A in the first category, while Y 1 =C in the second category. So for the input A/B B\\C, the output is a single category-combinator pair: (A\\C >Bx).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Combination", "sec_num": "4.1" }, { "text": "If the input were A/B C, the output would be an empty list since the second category C will not match the structure of either of the operand patterns.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Combination", "sec_num": "4.1" }, { "text": "Suppose now the input is a single category A. The composition combinators can be immediately discounted since they require two operands. However, it does match the single operand pattern for the type raising combinator, giving match dictionary {X 1 :A}. This conforms to both the forward and backward type-raising, so the function would output a pair list {(*/(*\\A) >T), (*\\(*/A) *,<*}", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Inverse Combination", "sec_num": "4.2" }, { "text": "where A, B, C are pattern placeholders ( -they are obviously not valid patterns themselves), >* represents some number of forward variations and <* represents some number of backward variations. Now suppose we know the left and result categories (c A and c C ), and wish to enumerate all valid right categories (c B ) -the missing-right scenario. This is achieved via a twostep process, involving the instantiation of two combine() functions: This works because combine 1 () returns the list of c B 's that result from valid matches of A:c A , C:c C . combine 2 () also matches A:c A , C:c C , but its operation is a little less obvious: because combine 2 () only considers backward combinations, it always reverses the order of its operands c A and c C , so A is still compared with c A , and C with c C .", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Inverse Combination", "sec_num": "4.2" }, { "text": "OPERANDS", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Inverse Combination", "sec_num": "4.2" }, { "text": "Inverse combination for the missing-left scenario can be performed similarly, so in the interest of brevity its detail is omitted.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Inverse Combination", "sec_num": "4.2" }, { "text": "While the above approach may seem awkward, keep in mind that no changes are required to the meta-grammar definition or to the implementation's code base. So inverse combination is obtained for free.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Inverse Combination", "sec_num": "4.2" }, { "text": "We have defined a meta-grammar for specifying complete families of CCG combinators. This metagrammar covers existing combinators, but more importantly, it provides a guide for specifying and using new combinators. A brief look at a preliminary implementation reveals that the metagrammar is indeed practical, and lends itself to powerful exploitation.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Conclusion", "sec_num": "5" }, { "text": "The authors would like to credit the work of Geoff Jarrad in developing these two combinators.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null } ], "back_matter": [ { "text": "This paper is based on work supported by Boeing and CSIRO, and by a Commonwealth scholarship (APA) plus Woodside PhD top-up scholarship to the first author. The authors would like to thank Geoff Jarrad for his input to discussions and assistance with reviewing. Many thanks also to the official reviewers for their helpful suggestions.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Acknowledgements", "sec_num": "6" } ], "bib_entries": { "BIBREF0": { "ref_id": "b0", "title": "Python Programming Language, Python Software Foundation", "authors": [], "year": 2004, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Python Programming Language, Python Software Foundation. 2004.", "links": null }, "BIBREF1": { "ref_id": "b1", "title": "Die syntaktische Konnexit\u00e4t", "authors": [ { "first": "K", "middle": [], "last": "Ajdukiewicz", "suffix": "" } ], "year": 1935, "venue": "Studia Philosophica", "volume": "1", "issue": "", "pages": "1--27", "other_ids": {}, "num": null, "urls": [], "raw_text": "Ajdukiewicz, K. (1935). \"Die syntaktische Konnexit\u00e4t.\" Studia Philosophica 1: 1-27.", "links": null }, "BIBREF2": { "ref_id": "b2", "title": "A Quasi-Arithmetical Notation for Syntactic Description", "authors": [ { "first": "Y", "middle": [], "last": "Bar-Hillel", "suffix": "" } ], "year": 1953, "venue": "Language", "volume": "29", "issue": "", "pages": "47--58", "other_ids": {}, "num": null, "urls": [], "raw_text": "Bar-Hillel, Y. (1953). \"A Quasi-Arithmetical Notation for Syntactic Description.\" Language 29: 47-58.", "links": null }, "BIBREF3": { "ref_id": "b3", "title": "Parsing the WSJ using CCG and Log-Linear Models", "authors": [ { "first": "S", "middle": [], "last": "Clark", "suffix": "" }, { "first": "J", "middle": [], "last": "Curran", "suffix": "" } ], "year": 2004, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Clark, S. and J. Curran (2004). Parsing the WSJ using CCG and Log-Linear Models. 42nd", "links": null }, "BIBREF4": { "ref_id": "b4", "title": "Annual Meeting of the Association for Computational Linguistics (ACL-04)", "authors": [], "year": null, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Annual Meeting of the Association for Computational Linguistics (ACL-04), Barcelona, Spain.", "links": null }, "BIBREF5": { "ref_id": "b5", "title": "Combinatory logic", "authors": [ { "first": "H", "middle": [], "last": "Curry", "suffix": "" }, { "first": "R", "middle": [], "last": "Feys", "suffix": "" } ], "year": 1958, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Curry, H. and R. Feys (1958). Combinatory logic. Amsterdam, North-Holland.", "links": null }, "BIBREF6": { "ref_id": "b6", "title": "The nature of the geological representation language and consequent constraints on machine interpretation", "authors": [ { "first": "C", "middle": [ "M" ], "last": "Griffiths", "suffix": "" } ], "year": 1989, "venue": "Advances in Geophysical Data Processing", "volume": "3", "issue": "", "pages": "49--77", "other_ids": {}, "num": null, "urls": [], "raw_text": "Griffiths, C. M. (1989). \"The nature of the geological representation language and consequent constraints on machine interpretation.\" Advances in Geophysical Data Processing 3: 49-77.", "links": null }, "BIBREF7": { "ref_id": "b7", "title": "Data and Models for Statistical Parsing with Combinatory Categorial Grammar", "authors": [ { "first": "J", "middle": [], "last": "Hockenmaier", "suffix": "" } ], "year": 2003, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Hockenmaier, J. (2003). Data and Models for Statistical Parsing with Combinatory Categorial Grammar. School of Informatics. Edinburgh, University of Edinburgh: 280.", "links": null }, "BIBREF9": { "ref_id": "b9", "title": "Generative Models for Statistical Parsing with Combinatory Categorial Grammar", "authors": [], "year": null, "venue": "40th Annual Meeting of the Association for Computational Linguistics", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Generative Models for Statistical Parsing with Combinatory Categorial Grammar. 40th Annual Meeting of the Association for Computational Linguistics, Philadelphia.", "links": null }, "BIBREF10": { "ref_id": "b10", "title": "The mathematics of sentence structure", "authors": [ { "first": "J", "middle": [], "last": "Lambek", "suffix": "" } ], "year": 1958, "venue": "American Mathematical Monthly", "volume": "65", "issue": "", "pages": "154--170", "other_ids": {}, "num": null, "urls": [], "raw_text": "Lambek, J. (1958). \"The mathematics of sentence structure.\" American Mathematical Monthly 65: 154-170.", "links": null }, "BIBREF11": { "ref_id": "b11", "title": "The Penn treebank: Annotating predicate argument structure", "authors": [ { "first": "M", "middle": [ "P" ], "last": "Marcus", "suffix": "" }, { "first": "G", "middle": [], "last": "Kim", "suffix": "" } ], "year": 1994, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Marcus, M. P., G. Kim, et al. (1994). The Penn treebank: Annotating predicate argument structure. Human Language Technology Workshop.", "links": null }, "BIBREF12": { "ref_id": "b12", "title": "Building a Large Annotated Corpus of English: The Penn Treebank", "authors": [ { "first": "M", "middle": [ "P" ], "last": "Marcus", "suffix": "" }, { "first": "B", "middle": [], "last": "Santorini", "suffix": "" } ], "year": 1993, "venue": "Computational Linguistics", "volume": "19", "issue": "2", "pages": "313--330", "other_ids": {}, "num": null, "urls": [], "raw_text": "Marcus, M. P., B. Santorini, et al. (1993). \"Building a Large Annotated Corpus of English: The Penn Treebank.\" Computational Linguistics 19(2): 313-330.", "links": null }, "BIBREF13": { "ref_id": "b13", "title": "Modelling, Simulation and Estimation of Situation Histories", "authors": [ { "first": "D", "middle": [], "last": "Mcmichael", "suffix": "" }, { "first": "G", "middle": [], "last": "Jarrad", "suffix": "" } ], "year": 2004, "venue": "7th International Conference on Information Fusion (Fusion 2004)", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "McMichael, D., G. Jarrad, et al. (2004). Modelling, Simulation and Estimation of Situation Histories. 7th International Conference on Information Fusion (Fusion 2004), Stockholm, Sweden, International Society for Information Fusion.", "links": null }, "BIBREF14": { "ref_id": "b14", "title": "Categorial grammar", "authors": [ { "first": "M", "middle": [], "last": "Steedman", "suffix": "" } ], "year": 1993, "venue": "Lingua", "volume": "90", "issue": "3", "pages": "221--258", "other_ids": {}, "num": null, "urls": [], "raw_text": "Steedman, M. (1993). \"Categorial grammar.\" Lingua 90(3): 221-258.", "links": null }, "BIBREF15": { "ref_id": "b15", "title": "Surface Structure and Interpretation", "authors": [ { "first": "M", "middle": [], "last": "Steedman", "suffix": "" } ], "year": 1996, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Steedman, M. (1996). Surface Structure and Interpretation. Massachusetts, MIT Press.", "links": null }, "BIBREF16": { "ref_id": "b16", "title": "The Syntactic Process", "authors": [ { "first": "M", "middle": [], "last": "Steedman", "suffix": "" } ], "year": 2000, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Steedman, M. (2000). The Syntactic Process. Massachusetts, MIT Press.", "links": null }, "BIBREF19": { "ref_id": "b19", "title": "Accessed 15", "authors": [], "year": 2004, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Accessed 15 September 2004.", "links": null } }, "ref_entries": { "FIGREF1": { "type_str": "figure", "num": null, "uris": null, "text": "Simple addition of the two returned lists obtains the desired result:combine 1 (c A ,c C ) + combine 2 (c A ,c C )" } } } }