<?xml version="1.0" standalone="yes"?>
<Paper uid="P86-1037">
  <Title>Some Uses of Higher-Order Logic in Computational Linguistics</Title>
  <Section position="2" start_page="0" end_page="247" type="intro">
    <SectionTitle>
1. Introduction
</SectionTitle>
    <Paragraph position="0"> The representation of meaning, and the use of such a representation to draw inferences, is an issue of central concern in natural language understanding systems. A theoretical understanding of meaning is generally based on logic, and it has been recognized that a higher-order logic is particularly well suited to this task. Montague, for example, used such a logic to provide a compositional semantics for simple English sentences. In the computational framework, knowledge representation systems are given the task of representing the semantical notions that are needed in natural This work has been supported by NSF grants MCS-8219196-CER, MCS-82-07294, AI Center grants MCS-8305221, US Army Research Office grant ARO-DAA29-849-0027, and DARPA N000-14-85-K-0018.</Paragraph>
    <Paragraph position="1"> language understanding programs. While the formal justifications that are provided for such systems is usually logical, the actual formalisms used are often distantly related to logic. Our approach in this paper is to represent meanings directly by using logical expressions, and to describe the process of inference by specifying manipulations on such expressions. As it turns out, most programming languages are poorly suited for an approach such as ours. Prolog, for instance, permits the representation and the examination of the structure of first-order terms, but it is not easy to use such terms to represent first-order formulas which contain quantification. Lisp on the other hand allows the construction of lambda expressions which could encode the binding operations of quantifiers, but does not provide logical primitives for studying the internal structure of such expressions. A language that is based on a higher-order logic seems to be the most natural vehicle for an approach such as ours, and in the first part of this paper we shall describe such a language. We shall then use this language to describe computations of a kind that is needed in a natural language understanding system.</Paragraph>
    <Paragraph position="2"> Before we embark on this task, however, we need to consider the arguments that are often made against the computational use of a higher-order logic. Indeed, several authors in the current literature on computational linguistics and knowledge representation have presented reasons for preferring first-order logic over higher-order logic in natural language understanding systems, and amongst these the following three appear frequently.</Paragraph>
    <Paragraph position="3"> (1} GSdel showed that second-order logic is essentially incomplete, i.e. true second-order logic statements are not recursively enumerable. Hence, theorem provers for this logic cannot be, even theoretically, complete.</Paragraph>
    <Paragraph position="4"> (2) Higher-order objects like functions and predicates can themselves be considered to be first-order objects of some sort. Hence, a sorted first-order logic can be used to encode higher-order objects.</Paragraph>
    <Paragraph position="5"> (3) Little research on theorem proving in higher-order logics has been done. Moreover, there is reason to believe that theorem proving in such a logic is extremely difficult. null These facts are often used to conclude that a higher-order logic should not be used to formalize systems if such formalizations are to be computationally meaningful.</Paragraph>
    <Paragraph position="6"> While there is some truth in each of these observations, we feel that they do not warrant the conclusion that is drawn from it. We discuss our reasons for this belief below.</Paragraph>
    <Paragraph position="7">  The point regarding the essential undecidability of second-order logic has actually little import on the computational uses of higher-order logic. This is because the second-order logic as it is construed in this observation, is not a proof system but rather a truth system of a very particular kind. Roughly put, the second-order logic in question is not so much a logic as it is a branch of mathematics which is interested in properties about the integers. There are higher-order logics that have been provided which contain the formulas of second-order logic but which do not assume the same notion of models (i.e. the integers). These logics, in fact, have general models, including the standard, integer model, as well as other non-standard models, and with respect to this semantics, the logic has a sound and complete proof system.</Paragraph>
    <Paragraph position="8"> From a theoretical point-of-view, the second observations is important. Indeed, any system which could not be encoded into first-order logic would be more powerful than Turing machines and, hence, would be a rather unsatisfactory computationally! The existence of such an encoding has little significance, however, with regard to the appropriateness of one language over another for a given set of computational tasks. Clearly, all general purpose programming languages can be encoded onto first-order logic, but this has little significance with regard to the suitability of a given programming language for certain applications.</Paragraph>
    <Paragraph position="9"> Although less work has been done on theorem proving in higher-order logic than in first-order logic as claimed in the last point, the nature of proofs in higher-order logic is far from mysterious. For example, higher-order resolution \[1\] and unification \[8\] has been developed, and based on these principles, several theorem provers for various higher-order logics (see \[2\] and its references) have been built and * / tested. The experience with such systems shows that theorem proving in such a logic is difficult. It is not clear, however, that the difficulty is inherent in the language chosen to express a theorem rather than in the theorem itself.</Paragraph>
    <Paragraph position="10"> In fact, expressing a higher-order theorem (as we will claim many statements about meaning are) in a higher-order logic makes its logical structure more explicit than an encoding into first-order logic does. Consequently, it is reasonable to expect that the higher-order representation should actually simplify the process of finding proofs. In a more specific sense, there are sublogics of a higher-order logic in which the process of constructing proofs is not much more complicated than in similar sublogics of first-order logic.</Paragraph>
    <Paragraph position="11"> An example of such a case is the higher-order version of definite clauses that we shall consider shortly.</Paragraph>
    <Paragraph position="12"> In this paper, we present a higher-order version of definite clauses that may be used to specify computations, and we describe a logic programming language, ,~Prolog, that is based on this specification language. We claim that ~Prolog has several linguistically meaningful applications.</Paragraph>
    <Paragraph position="13"> To bolster this claim we shall show how the syntactic and semantic processing used within a simple parser of natural language can be smoothly integrated into one logical and computational process. We shall first present a definite clause grammar that analyses the syntactic structure of simple English sentences to produce logical forms in much the same way as is done in the Montague framework. We shall then show how semantic analyses may be specified via operations on such logical forms. Finally, we shall illustrate interactions between these two kinds of analyses by considering an example of determining pronoun reference.</Paragraph>
  </Section>
class="xml-element"></Paper>