Grammar Engineering Research Articles

Grammar Customization

This paper presents the LinGO Grammar Matrix grammar customization system, a web-based service which elicits typological descriptions of languages and outputs customized grammar fragments which are ready for sustained development into broad-coverage grammars. We describe the infrastructure we have developed to support grammar customization as well as the current set of linguistic phenomena addressed, reflect on what we have learned about a methodology for this style of multilingual grammar engineering, and evaluate the typological breadth of the system by using it to create grammars for seven languages from seven different language families.

Reweaving a Grammar for Wambaya

This paper presents a case study in grammar engineering for linguistic hypothesis testing, focusing on the treatment of second position auxiliaries in an HPSG grammar for Wambaya. A detailed comparison of two versions of this grammar highlights the interconnectedness of linguistic phenomena, the model-dependence of linguistic analyses, and the value of computational support in calculating the consequences of differing analytical choices.

Grammar Engineering Support for Precedence Rule Recovery and Compatibility Checking

A wide range of parser generators are used to generate parsers for programming languages. The grammar formalisms that come with parser generators provide different approaches for defining operator precedence. Some generators (e.g. YACC) support precedence declarations, others require the grammar to be unambiguous, thus encoding the precedence rules. Even if the grammar formalism provides precedence rules, a particular grammar might not use it. The result is grammar variants implementing the same language. For the C language, the GNU Compiler uses YACC with precedence rules, the C-Transformers uses SDF without priorities, while the SDF library does use priorities. For PHP, Zend uses YACC with precedence rules, whereas PHP-front uses SDF with priority and associativity declarations.The variance between grammars raises the question if the precedence rules of one grammar are compatible with those of another. This is usually not obvious, since some languages have complex precedence rules. Also, for some parser generators the semantics of precedence rules is defined operationally, which makes it hard to reason about their effect on the defined language. We present a method and tool for comparing the precedence rules of different grammars and parser generators. Although it is undecidable whether two grammars define the same language, this tool provides support for comparing and recovering precedence rules, which is especially useful for reliable migration of a grammar from one grammar formalism to another. We evaluate our method by the application to non-trivial mainstream programming languages, such as PHP and C.

Urdu in a parallel grammar development environment

In this paper, we report on the role of the Urdu grammar in the Parallel Grammar (ParGram) project (Butt, M., King, T. H., Niño, M.-E., & Segond, F. (1999). A grammar writer’s cookbook. CSLI Publications; Butt, M., Dyvik, H., King, T. H., Masuichi, H., & Rohrer, C. (2002). ‘The parallel grammar project’. In: Proceedings of COLING 2002, Workshop on grammar engineering and evaluation, pp. 1–7). The Urdu grammar was able to take advantage of standards in analyses set by the original grammars in order to speed development. However, novel constructions, such as correlatives and extensive complex predicates, resulted in expansions of the analysis feature space as well as extensions to the underlying parsing platform. These improvements are now available to all the project grammars.

Modular Grammar Engineering in GF

The Grammatical Framework GF is a grammar formalism designed for multilingual grammars. A multilingual grammar has a shared representation, called abstract syntax, and a set of concrete syntaxes that map the abstract syntax to different languages. A GF grammar consists of modules, which can share code through inheritance, but which can also hide information to achieve division of labour between grammarians working on different modules. The goal is to make it possible for linguistically untrained programmers to write linguistically correct application grammars encoding the semantics of special domains. Such programmers can rely on resource grammars, written by linguists, which play the role of standard libraries. Application grammarians use resource grammars through abstract interfaces, and the type system of GF guarantees that grammaticality is preserved. The ongoing GF resource grammar project provides resource grammars for ten languages. In addition to their use as libraries, resource grammars serve as an experiment showing how much grammar code can be shared between different languages.

Shared Representation in Multilingual Grammar Engineering

Shared Representation in Multilingual Grammar Engineering

Head-initial constructions in Japanese

Japanese is often taken to be strictly head-final in its syntax. In our work on a broad-coverage, precision implemented HPSG for Japanese, we have found that while this is generally true, there are nonetheless a few minor exceptions to the broad trend. In this paper, we describe the grammar engineering project, present the exceptions we have found, and conclude that this kind of phenomenon motivates on the one hand the HPSG type hierarchical approach which allows for the statement of both broad generalizations and exceptions to those generalizations and on the other hand the usefulness of grammar engineering as a means of testing linguistic hypotheses.

The Grammar Deployment Kit — System Demonstration —

Grammar deployment is the process of turning a given grammar specification into a working parser. The Grammar Deployment Kit (for short, GDK) provides tool support in this process based on grammar engineering methods. We are mainly interested in the deployment of grammars for software renovation tools, that is, tools for software re- and reverse engineering. The current version of GDK is optimized for Cobol. We assume that grammar deployment starts from an initial grammar specification which is maybe still ambiguous or even incomplete. In practice, grammar deployment binds unaffordable human resources because of the unavailability of suitable grammar specifications, the diversity of parsing technology as well as the limitations of the technology, integration problems regarding the development of software renovation functionality, and the lack of tools and adherence to firm methods for grammar engineering. GDK helps to largely automate grammar deployment because tool support for grammar adaptation and parser generation is provided. We support different parsing technologies, among them btyacc, that is, yacc with backtracking. GDK is free software.

Towards systematic grammar profiling.Test suite technology 10 years after

An experiment with recent test suite and grammar (engineering) resources is outlined: a criticial assessment of the EU-fundedtsnlp(Test Suites for Natural Language Processing) package as a diagnostic and benchmarking facility for a distributed (multi-site) large-scalehpsggrammar engineering effort. This paper argues for a generalized, systematic, and fully automated testing and diagnosis facility as an integral part of the linguistic engineering cycle and gives a practical assessment of existing resources; both a flexible methodology and tools for competence and performance profiling are presented. By comparison to earlier evaluation work as reflected in the Hewlett-Packard test suite data, released exactly 10 years beforetsnlp, it is judged where test-suite-based evaluation has improved (and where not) over time.

Concurrent, object-oriented natural language parsing: the ParseTalk model

The ParseTalk model of concurrent, object-oriented natural language parsing is introduced. It builds upon the complete lexical distribution of grammatical knowledge and incorporates inheritance mechanisms in order to express generalizations over sets of lexical items. The grammar model integrates declarative well-formedness criteria constraining linguistic relations between heads and modifiers, and procedural specifications of the communication protocol for establishing these relations. The parser's computation model relies upon the actor paradigm, with concurrency entering through asynchronous message passing. We consider various extensions of the basic actor model as required for distributed natural language understanding and elaborate on the semantics of the actor computation model in terms of event type networks (a graph representation for actor grammar specifications) and event networks (graphs which represent the actor parser's behavior). Besides theoretical claims, we present an interactive grammar/parser workbench, a graphical development environment with various types of browsers, tracers, inspectors and debuggers, that has been adapted to the requirements of large-scale grammar engineering in a distributed, object-oriented specification and programming framework.

Building integrated software development environments. Part I

The conceptual modeling approach of the IPSEN (Integrated Project Support Environment) project for building highly integrated environments is based on using attributed graphs to model and implement arbitrary object structures, in particular all kinds of software documents and their relationships. A language based on graph grammars, called PROGRESS (PROgrammed Graph REwriting SyStems), and a suitable method for the application of this language, called graph grammar engineering, have been developed over the last ten years. This language and method are being extensively used for specifying the complex graph structures of internal document representations as well as for specifying the functionality of all tools (editors, browsers, analyzers, debuggers) working on these internal rpresentations. This paper explains the language and the method for applying the language based on a pragmatic nontrivial example of a software production process and its corresponding documents. In particular, it is shown why and how a graph grammar-based strongly typed language is perfectly suitable to formally specify highly integrated software tools. In addition, it is shown that the implementation of these tools (i.e., an environment composed of these tools) is systematically being derived from the formal specifications.

Engineering Course at High Pavement School, Nottingham

This experimental grammar school engineering course is to continue, writes our correspondent, though the Institution of Mechanical Engineers has decided not to renew the helpful concession it made