A higher order logic parser for natural language implemented in Lambda Prolog

This paper describes an implementation of some of the ideas presented by F.C.N. Pereira in [1]. Pereira uses a sequent-calculus like system to produce Montague semantics from natural language. The lefthand sequent can be interpreted as a set of constraints under which a given sentence fragment has a certain interpretation. Pereira presents a few complementary "discharge-rules" to reduce the number of such constraints. These conditional interpretations constitute a uniform way to represent partial knowledge during the parsing process. The implementation this paper describes is done in Lambda Prolog [2]. Lambda Prolog is a generalization of horn-clause logic to higher order logic, based on the higher order unification procedure of Huet [3]. It appears that the implementation of Pereira's system in Lambda Prolog becomes very natural. The higher order unification mechanism of Lambda takes care of the complicated binding mechanisms in Pereira's "discharge-rules" in a very simple and elegant way. Finally, the paper discusses some problems with the implementation and gives a few suggestions on how these could be overcome

Robust Grammatical Analysis for Spoken Dialogue Systems

We argue that grammatical analysis is a viable alternative to concept spotting for processing spoken input in a practical spoken dialogue system. We discuss the structure of the grammar, and a model for robust parsing which combines linguistic sources of information and statistical sources of information. We discuss test results suggesting that grammatical processing allows fast and accurate processing of spoken input.Comment: Accepted for JNL

Constraining Montague Grammar for computational applications

This work develops efficient methods for the implementation of Montague Grammar on a computer. It covers both the syntactic and the semantic aspects of that task. Using a simplified but adequate version of Montague Grammar it is shown how to translate from an English fragment to a purely extensional first-order language which can then be made amenable to standard automatic theorem-proving techniques. Translating a sentence of Montague English into the first-order predicate calculus usually proceeds via an intermediate translation in the typed lambda calculus which is then simplified by lambda-reduction to obtain a first-order equivalent. If sufficient sortal structure underlies the type theory for the reduced translation to always be a first-order one then perhaps it should be directly constructed during the syntactic analysis of the sentence so that the lambda-expressions never come into existence and no further processing is necessary. A method is proposed to achieve this involving the unification of meta-logical expressions which flesh out the type symbols of Montague's type theory with first-order schemas. It is then shown how to implement Montague Semantics without using a theorem prover for type theory. Nothing more than a theorem prover for the first-order predicate calculus is required. The first-order system can be used directly without encoding the whole of type theory. It is only necessary to encode a part of second-order logic and this can be done in an efficient, succinct, and readable manner. Furthermore the pseudo-second-order terms need never appear in any translations provided by the parser. They are vital just when higher-order reasoning must be simulated. The foundation of this approach is its five-sorted theory of Montague Semantics. The objects in this theory are entities, indices, propositions, properties, and quantities. It is a theory which can be expressed in the language of first-order logic by means of axiom schemas and there is a finite second-order axiomatisation which is the basis for the theorem-proving arrangement. It can be viewed as a very constrained set theory

Foundations of Programming Languages

This clearly written textbook provides an accessible introduction to the three programming paradigms of object-oriented/imperative, functional, and logic programming. Highly interactive in style, the text encourages learning through practice, offering test exercises for each topic covered. Review questions and programming projects are also presented, to help reinforce the concepts outside of the classroom. This updated and revised new edition features new material on the Java implementation of the JCoCo virtual machine

Adding plural arguments to Curry programs

Functional logic languages combine lazy (demand-driven) evaluation strategies from functional programming with non-deterministic computations from logic programming. To provide a strategy-independent semantics, most languages are based on the call-time choice semantics where parameters are passed as values. From an implementation point of view, the call-time choice semantics fits well with sharing performed by lazy languages. On the other hand, there are also situations where it is intended to pass non-deterministic arguments as sets of values in order to exploit the power of non-deterministic programming. This alternative parameter passing model is known under the name "plural" arguments. In this paper, we show how both mechanisms can be integrated in a single language. In particular, we present a novel technique to implement plural arguments in a call-time choice language so that existing implementations of contemporary functional logic languages can be easily re-used to implement plural parameter passing

NATURAL DEDUCTION AS HIGHER-ORDER RESOLUTION

An interactive theorem prover, Isabelle, is under development. In LCF, each inference rule is represented by one function for forwards proof and another (a tactic) for backwards proof. In Isabelle, each inference rule is represented by a Horn clause. Resolution gives both forwards and backwards proof, supporting a large class of logics. Isabelle has been used to prove theorems in Martin-L\"of's Constructive Type Theory. Quantifiers pose several difficulties: substitution, bound variables, Skolemization. Isabelle's representation of logical syntax is the typed lambda-calculus, requiring higher- order unification. It may have potential for logic programming. Depth-first subgoaling along inference rules constitutes a higher-order Prolog

Transition and Parsing State and Incrementality in Dynamic Syntax

PACLIC 21 / Seoul National University, Seoul, Korea / November 1-3, 200