This issue of Natural Language Engineering journal reports on recent achievements in the domain of HPSG-based parsing. Research groups at Saarbrücken, CSLI Stanford and the University of Tokyo have worked on grammar development and processing systems that allow the use of HPSG-based processing in practical application contexts. Much of the research reported here has been collaborative, and all of the work shares a commitment to producing comparable results on wide-coverage grammars with substantial test suites. The focus of this special issue is deliberately narrow, to allow detailed technical reports on the results obtained among the collaborating groups. Thus, the volume cannot aim at providing a complete survey on the current state of the field. This introduction summarizes the research background for the work reported in the issue, and puts the major new approaches and results into perspective. Relationships to similar efforts pursued elsewhere are included, along with a brief summary of the research and development efforts reflected in the volume, the joint reference grammar, and the common sets of reference data.

Modern grammar development platforms often support multiple devices for representing properties of a natural language, giving the grammar writer some freedom in implementing analyses of linguistic phenomena. These design alternatives can have dramatic consequences for efficiency both in processing and in grammar building. In this paper I report on three experiments in making systematic modifications to a broad-coverage grammar of English in order to gain efficiency without loss of linguistic elegance. While the experiments are to some degree both platform-dependant and theory-bound, the kinds of modifications reported should be applicable to any unification-based grammar which makes use of types. The results make a strong case for a more visible role for the linguist in the collaborative effort to achieve greater processing efficiency.

One major obstacle to the efficient processing of large wide coverage grammars in unification-based grammatical frameworks such as HPSG is the time and space cost of the unification operation itself. In a grammar development system it is not appropriate to address this problem with techniques which involve lengthy compilation, since this slows down the edit-test-debug cycle. Nor is it possible to radically restructure the grammar. In this paper, we describe novel extensions to an existing efficient unification algorithm which improve its space and time behaviour (without affecting its correctness) by substantially increasing the amount of structure sharing that takes place. We also describe a fast and automatically tunable pre-unification filter (the ‘quick check’) which in practice detects a large proportion of unifications that if performed would fail. Finally, we present an efficient algorithm for checking for subsumption relationships between two feature structures; a special case of this gives a fast equality test. The subsumption check is used in a parser (described elsewhere in this issue) which ‘packs’ local ambiguities to avoid performing redundant sub-computations.

This article evaluates the efficiency of the LiLFeS abstract machine by performing parsing tasks with the LinGO English resource grammar. The instruction set of the abstract machine is optimized for efficient processing of definite clause programs and typed feature structures. LiLFeS also supports various tools required for efficient parsing (e.g. efficient copying, a built-in CFG parser) and the constructions of standard Prolog (e.g. cut, assertions, negation as failure). Several parsers and large-scale grammars, including the LinGO grammar, have been implemented in or ported to LiLFeS. Precise empirical results with the LinGO grammar are provided to allow comparison with other systems. The experimental results demonstrate the efficiency of the LiLFeS abstract machine.

This article presents an HPSG parser using a technique called CFG filtering. The parser predicts possible parse trees using a CFG generated automatically from a given HPSG-based grammar. Parsing costs are reduced because unification is applied only to the predicted parse trees. In other words, parsing is speeded up because the parser avoids unnecessary unification by eliminating impossible parse trees. We show the method for generating a CFG from an HPSG-based grammar and outline a parsing scheme using the CFG. The effectiveness of the parsing scheme is shown through experimental results obtained by using several HPSG-based grammars, including the LinGO grammar.

We describe and argue for a strategy of performance profiling and comparison in the engineering of parsing systems for wide-coverage linguistic grammars. A performance profile is a precise, rich and structured snapshot of system (and grammar) behaviour at a given development point. The aim is to characterize system performance at a very detailed technical level, but at the same time to abstract away from idiosyncracies of particular processors. Profiles are obtained with minimal effort by applying a specialized profiling tool to a set of structured reference data (taken from both existing test suites and corpora), in conjunction with a uniform format for test data and processing results. The resulting profiles can be analyzed and visualized at various levels of granularity in order to highlight different aspects of system performance, thus providing a solid empirical basis for system refinement and optimization. Since profiles are stored in a database, comparison with earlier versions, different parameter settings, or other processing systems is straightforward. We apply several salient performance metrics in a contrastive discussion of various (one-pass, bottom-up, chart-based) parsing strategies (viz. passive vs. active and uni- vs. bidirectional approaches). Based on insights gained from detailed performance profiles, we outline and evaluate a novel ‘hyper-active’ parsing strategy. We also present preliminary profiles for techniques for ‘packing’ of local ambiguities with respect to (partial) subsumption of feature structures.

The PET platform for experimentation with hpsg processing and implementation techniques is introduced. PET provides an extendible set of building blocks for the implementation of efficient processors. This enables straightforward comparison of different approaches, rapid development of new techniques and easy synthesis of known techniques. An overview of the basic design is given and key aspects of the implementation are discussed. Early empirical results on the three standard test sets for the LinGO grammar are given. Two improved expansion strategies are evaluated empirically. The results of fine tuning the quick check filtering method through empirical study are discussed as an exemplar of the proposed experimental approach to the development and optimization of processing techniques. An overview of the progress in processing the LinGO grammar made over a development period of three years is given.

The LinGO grammar consists of a specification of a type system and of various typed feature structures which are well-formed according to the type system. The typed feature structures function as grammar rules, lexical rules and lexical entries. There are several variant typed feature structure formalisms, with different computational properties, so in this appendix we very briefly specify the version assumed by the LinGO grammar.

This appendix is necessarily terse, and is only intended to allow a reader who already has a knowledge of typed feature structures to understand the specific formalism used in the LinGO grammar. The definitions given below basically follow Carpenter (1992), with the notion of type constraint from Copestake (1992). For formal details of typed feature structures in general see Carpenter (1992). A detailed account of the specific assumptions made here is given in Copestake (1999) (See Chapter 4 for an introduction, and Chapter 5 for a semi-formal account.)

Note that the LinGO grammar uses a very restricted formalism. For instance, it does not utilize disjunctive feature structures, negation, implication, inequalities, defaults, set-valued features, extensionality or relational constraints. Constraint resolution does not require that every type be made maximally specific, and the type inference system is essentially non-recursive. The recursive power necessary in grammars is explicitly encoded via rules, which are expressed as typed feature structures, but interpreted as phrase structure rules.