Bengt Nordström

The ALF proof editor and its proof engine

Alf is an interactive proof editor. It is based on the idea that to prove a mathematical theorem is to build a proof object for the theorem. The proof object is directly manipulated on the screen, different manipulations correspond to different steps in the proof. The language we use is Martin-Lofs monomorphic type theory. This is a small functional programming language with dependent types. The language is open in the sense that it is easy to introduce new inductively defined sets. A proof is represented as a mathematical object and a proposition is identified with the set of its proof objects. The basic part of the proof editor can be seen as a proof engine with two basic commands, one which builds an object by replacing a placeholder in an object by a new object, and another one which deletes a part of an object by replacing a sub-object by a placeholder. We show that the validity of the incomplete object is preserved by admissible insertions and deletions.

Terminating general recursion

In Martin-Löfs type theory, general recursion is not available. The only iterating constructs are primitive recursion over natural numbers and other inductive sets. The paper describes a way to allow a general recursion operator in type theory (extended with propositions). A proof rule for the new operator is presented. The addition of the new operator will not destroy the property that all well-typed programs terminate. An advantage of the new program construct is that it is possible to separate the termination proof of the program from the proof of other properties.

Programming in Constructive Set Theory: Some examples

Per Martin-Löfs Constructive Set Theory is a mathematical language with computation rules. It is primarily designed to be a language for mathematical reasoning. The language has a very simple semantics and its rules have a simple structure. Since it is a language for constructive mathematics, it is possible to execute the proof (the construction of a proposition) as a program. The language can be seen as a programming language without assignments and other side effects. Compared to traditional functional languages it has a very rich type structure in that the type of an expression can completely specify the task of the exprestion. A sorting algorithm, for instance, can be conventionally specified to have a type sort: List(A) → List(A) which is type-correct if sort is any function taking a list as argument and producing a list as result. It is, however, also possible to specify that sort is a function taking a list as argument and producing a sorted permutation of it s input as result, i.e. sort: (@@@@ x ε List(A)) (&Sgr; y ε List(A)) (Perm(x,y) × Sorted(y)) The type (or the task) of the program can be read as the proposition (@@@@x ε List(A)) (@@@@y ε List(A) (Perm(x,y) & Sorted(y)) which is read “for all lists x, there is a sorted permutation y of x”. We can prove that this proposition is true, using the rules of the language to construct a program for the task. If the proposition were not true, it would be impossible to find a program for it and we would have had an impossible task. The types of Constructive Set Theory can be seen as a specification language for the programs, but of course there is only one language, avoiding the complexity of mixing a programming language with a logical language. The similarity (or rather: identity) between a mathematical proof of a given proposition and a program for a given task suggests that programming should be similar to the mathematicians activity of finding proofs. We have illustrate d this with an example of how a proof of the Euclidean division theorem yields a program to compute the quotient and the remainder between two natural numbers. The paper contains a description of the language. Since all programs in the language terminate, the proof rules and the semantics are simple. We give some examples of programming with lists and reasoning about the programs. We also define the Ackermann function.

Multilingual syntax editing in GF

GF (Grammatical Framework) makes it possible to perform multilingual authoring of documents in restricted languages. The idea is to use an object in type theory to describe the common abstract syntax of a document and then map this object to a concrete syntax in the different languages using linearization functions, one for each language. Incomplete documents are represented using metavariables in type theory. The system belongs to the tradition of logical frameworks in computer science. The paper gives a description of how a user can use the editor to build a document in several languages and also shows some examples how ambiguity is resolved using type checking. There is a brief description of how GF grammars are written for new domains and how linearization functions are defined.

Propositions and specifications of programs in Martin-Löf's type theory

The constructive meaning of mathematical propositions makes it possible to identify specifications for computer programs with propositions. In Martin-Löfs type theory, constructing a program satisfying a specification corresponds to proving the proposition expressing the specification. These ideas are explained and some examples of specifications are given.

An outline of a mathematical model for the definition and manipulation of data

This paper presents a constructive model for data which suggests some precise definitions of notions like type, name, constants, declarations etc. The model is based on an old idea of looking at data as a mapping from a set of names to a set of values. We will study two different kinds of assignments and also show how the model can be used to give some hints for new data structuring methods. In particular we have given a definition of a sequence and we have shown how this data structure can be used to give constructive definitions of structures like stacks, files and queues. We have also studied tree traversals i.e. the correspondence between various trees and sequences.

The design of an interactive program development system for Pascal

A program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program‐structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.

A simple type-theoretic language: Mini-TT

This paper presents a formal description of a small functional language with dependent types. The language contains data types, mutual recursive/ inductive definitions and a universe of small types. The syntax, semantics and type system is specified in such a way that the implementation of a parser, interpreter and type checker is straightforward. The main difficulty is to design the conversion algorithm in such a way that it works for open expressions. The paper ends with a complete implementation in Haskell (around 400 lines of code).

Advances in Natural Language Processing

This book constitutes the refereed proceedings of the 6th International Conference on Natural Language Processing, GoTAL 2008, Gothenburg, Sweden, August 2008. The 44 revised full papers presented together with 3 invited talks were carefully reviewed and selected from 107 submissions. The papers address all current issues in computational linguistics and monolingual and multilingual intelligent language processing - theory, methods and applications.

Towards a Theory of Document Structure

The structure of documents of various degree of formality, from scientific papers with layout information and programs with their documentation to completely formal proofs can be expressed by assigning a type to the abstract syntax tree of the document. By using dependent types – an idea from type theory – it is possible to express very strong syntactic criterion on wellformedness of documents. This structure can be used to automatically generate parsers, type checkers and structure oriented editors.