Reduction (draft) Sven Eric Panitz Fachbereich Informatik Johann Wolfgang Goethe-Universitat Postfach 11 19 32 D-60054 Frankfurt Germany e-mail: panitz@informatik.uni-frankfurt.de June 3, Contents 1 Introduction 1 2 Termination Tableaux 3 2.1 The Language of Discourse . . . . . . . . . . . . . . . . . . . . . . 3 2.1.1 The Type System . . . . . . . . . . . . . . . . . . . . . . . 3 2.1.2 Expressions and Super-combinator Definitions . . . . . . . 3 2.1.3 Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Abstract Expressions . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3 Termination Tableaux . . . . . . . . . . . . . . . . . . . . . . . . 6 2.3.1 Expansion-rules . . . . . . . . . . . . . . . . . . . . . . . . 9 ffi-rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Abstract ffi-rules . . . . . . . . . . . . . . . . . . . . . . . . 9 Context Skipping and T-Introduction . . . . . . . . . . . 11 2.3.2 Closing a Tableau . . . . . . . . . . . ....

The construction of natural-language interfaces to computers continues to be a major challenge. The need for such interfaces is growing now that speech-recognition technology is becoming morereadily available, and people cannot speak those computer-oriented formal languages that are frequently used to interact with computer applications. Much of the research related to the design and implementation of natural-language interfaces has involved the use of high-level declarative programming languages. This is to be expected as the task is extremely difficult, involving syntactic and semantic analysis of potentially-ambiguous input. The use of LISP and Prolog in this area is well documented. However, research involving the relatively-new lazy functional-programming paradigm is less well known. This paper provides a comprehensive survey of that research.

We describe how type information can be used to infer grammatical structure. This is in contrast to conventional type inference in programming languages where the roles are reversed, structure determining type. Our work is based on Applicative Universal Grammar (AUG), a linguistic theory that views the formation of phrase in a form that is analogous to function application in a programming language. We descibe our overall methodology including its linguistic and philosophical underpinnings.

control structures................................................................. 3 3.2. Lazy data structures .......................................................................................... 4 3.2.1. Non-strict CONS cells ....................................................................... 4 3.2.2. Streams ............................................................................................. 5 4. Why lazy evaluation is not implemented in imperative languages ....................................... 8 4.1. Referential transparency.................................................................................... 9 4.2. Implementation ................................................................................................. 9 5. The signal processing model in an imperative language...................................................... 10 5.1. Code framework................................................................................................ 11 5.2....

We argue it is better to program in a natural language such as English, instead of a programming language like Java. A natural language interface for programming should result in greater readability, as well as making possible a more intuitive way of writing code. In contrast to previous controlled language systems, we allow unrestricted syntax, using wide-coverage syntactic and semantic methods to extract information from the user’s instructions. We also look at how people actually give programming instructions in English, collecting and annotating a corpus of such statements. We identify differences between sentences in this corpus and in typical newspaper text, and the effect they have on how we process the natural language input. Finally, we demonstrate a prototype system, that is capable of translating some English instructions into executable code. 1

. Automatically proving first order logic theorems is one of the keystones of artificial intelligence. We propose a set of exercises which lead to the Haskell implementation of a resolution based theorem prover for first order logic. For a start the exercises carry out Searle's Chinese Room thought experiment adapted to theorem proving. The implementation is handy enough to be made by students within a seminar which accompanies an introductory course to artificial intelligence; experiences in different proof strategies and optimization techniques can be made. The possibility of handling infinite data structures in a lazily evaluated language helps to learn semantical notions of first order logic from the program. 1 Introduction First order predicate logic is one of the most important formalism in artificial intelligence. First order logic is used e.g. in knowledge representation, expert systems, deductive data bases, planning systems, natural language processing, logic programming and...

It is the business of the computational linguist to give an account of how language is used — that is, to explain how it is that a physically-realizable system could ever give rise to the diversity of language behaviors that ordinary people exhibit. At least, this is

Almost forty years ago Richard Montague proposed to analyse natural language with the same tools as formal languages. In particular, he gave formal semantic analyses of several interesting fragments of English in terms of typed logic. This led to the development of Montague grammar as a particular style of formal analysis of natural language. Pure functional programming languages are in fact implementations of the typed lambda calculus, and implementing a Montague style fragment of English in Haskell is a breeze. In the talk we will first explain the program of Montague style natural language analysis, and next show how this can be carried out with functional programming. Examples will be taken from a textbook on computational semantics, Computational Semantics with Functional Programming (CUP, to appear). Draft version of the book: