Paul J. Voda

The Surprising Power of Restricted Programs and Gödel’s Functionals

Consider the following imperative programming language. The programs operate on registers storing natural numbers, the input \(\vec{x}\) is stored in certain registers, and a number b, called the base, is fixed to \(\max(\vec{x},1)+1\) before the execution starts. The single primitive instruction \(\verb/X+/\) increases the number stored in the register \(\verb/X/\) by 1 modulo b. There are two control structures: the loop \(\verb+while X{P}+\) executing the program \(\verb+P+\) repeatedly as long as the content of the register \(\verb/X/\) is different from 0; the composition \(\verb+P+\texttt{;} \verb+Q+\) executing first the program \(\verb/P/\), then the program \(\verb/Q/\). This is the whole language. The language is natural, extremely simple, yet powerful. We will prove that it captures \(\mbox{\sc linspace}\), i.e. the numerical relations decidable by such programs are exactly those decidable by Turing machines working in linear space. Variations of the language capturing other important deterministic complexity classes, like e.g. \(\mbox{\sc logspace}\), \(\mbox{\sc p}\) and \(\mbox{\sc pspace}\) are possible (see Kristiansen and Voda [5]).

The trade-off theorem and fragments of Gödel’s T

In [3, 4] we study the functionals, functions and predicates of the system T−−. Roughly speaking, T−− is a version of Godel’s T (see, for instance [1]) where the successor function cannot be used to define functionals, and a functional F is definable in T−− iff F is definable in Godel’s T by a term t where no succesors occur in t (the numerical constant 1 might occur in t).

Subrecursion as a Basis for a Feasible Programming Language

We are motivated by finding a good basis for the semantics of programming languages and investigate small classes in subrecursive hierarchies of functions. We do this with the help of a pairing function because in this way we can explore the amazing coding powers of S-expressions of LISP within the domain of natural numbers. We introduce three Grzegorczyk-like hierarchies based on pairing and characterize them both in terms of Grzegorczyk hierarchy and computational complexity.

Syntactic Reduction of Predicate Tableaux to Propositional Tableaux

We refine the semantic process which reduces predicate logic (with equality) to propositional tautologies. We then devise a tableau based proof system mirroring the semantic process by purely syntactic (i.e. programmable) means. We obtain a beautifully symmetric set of theorems given in Fig. 1. As a byproduct of the refinement we have a proof system without the eigen-variable condition.

The structure of detour degrees

We introduce a new subrecursive degree structure: the structure of detour degrees. We provide definitions and basic properties of the detour degrees, including that they form a lattice and admit a jump operator. Our degree structure sheds light upon the open problems involving the small Grzegorcyk classes. There are also connections to complexity theory and complexity classes defined by resource-bounded Turing machines.

Theorems af Péter and Parsons in Computer Programming

This paper describes principles behind a declarative programming language CL (Clausal Language) which comes with its own proof system for proving properties of defined functions and predicates. We use our own implementation of CL in three courses in the first and second years of undergraduate study. By unifying the domain of LISP’s S-expressions with the domain ℕ of natural numbers we have combined the LISP-like simplicity of coding with the simplicity of semantics. We deal just with functions over ℕ within the framework of formal Peano arithmetic. We believe that most of the time this is as much as is needed. CL is thus an extremely simple language which is completely based in mathematics.

Computer Programming as Mathematics in a Programming Language and Proof System CL

CL (Clausal Language) is a computer programming language with mathematical syntax and a proof system based on Peano arithmetic which we have repeatedly used in the teaching of three (first and second year) undergraduate courses covering respectively declarative programming, program verification, and program and abstract data specification.