Lars Kristiansen

On the computational complexity of imperative programming languages

Two restricted imperative programming languages are considered: One is a slight modification of a loop language studied intensively in the literature, the other is a stack programming language over an arbitrary but fixed alphabet, supporting a suitable loop concept over stacks. The paper presents a purely syntactical method for analysing the impact of nesting loops on the running time. This gives rise to a uniform measure µ on both loop and stack programs, that is, a function that assigns to each such program P a natural number µ(P) computable from the syntax of P.It is shown that stack programs of µ-measure n compute exactly those functions computed by a Turing machine whose running time lies in Grzegorczyk class en-2. In particular, stack programs of µ-measure 0 compute precisely the polynomial-time computable functions.Furthermore, it is shown that loop programs of µ-measure n compute exactly the functions in en-2. In particular, loop programs of µ-measure 0 compute precisely the linear-space computable functions.

Neat function algebraic characterizations of logspace and linspace

Abstract.We characterize complexity classes by function algebras that neither contain bounds nor any kind of variable segregation. The class of languages decidable in logarithmic space is characterized by the closure of a neat class of initial functions (projections and constants) under composition and simultaneous recursion on notation. We give a similar characterization of the class of number-theoretic 0–1 valued functions computable in linear space using simultaneous recursion on natural numbers in place of simultaneous recursion on notation.

The flow of data and the complexity of algorithms

Let C be a program written in a formal language in order to be executed by some kind of machinery. A statement about C might be true or false and has the form C:M. For the time being, just consider the statement C:M as a collection of data yielding information about the resources required to execute C; and if we know that C:M is true (or false), we know something useful when it comes to determine the computational complexity of C. Let Γ be a set of statements, and let Γ⊧C:M denote that C:M will be true if all the statements in Γ are true. (The statements in Γ might say something about the computational complexity of the subprograms of C.) If Γ = 0, we will simply write⊧C:M.

A flow calculus of mwp -bounds for complexity analysis

We present a method for certifying that the values computed by an imperative program will be bounded by polynomials in the programs inputs. To this end, we introduce <i>mwp</i>-matrices and define a semantic relation ⊧ C : <i>M</i>, where C is a program and <i>M</i> is an <i>mwp</i>-matrix. It follows straightforwardly from our definitions that there exists <i>M</i> such that ⊧ C : <i>M</i> holds iff every value computed by C is bounded by a polynomial in the inputs. Furthermore, we provide a syntactical proof calculus and define the relation ⊢ C : <i>M</i> to hold iff there exists a derivation in the calculus where C : <i>M</i> is the bottom line. We prove that ⊢ C : <i>M</i> implies ⊧ C : <i>M</i>. By means of exhaustive proof search, an algorithm can decide if there exists <i>M</i> such that the relation ⊢ C : <i>M</i> holds, and thus, our results yield a computational method.

The small grzegorczyk classes and the typed λ-calculus

The class

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

\Delta^\mathbb{N}_{0}

Streamlined subrecursive degree theory

of rudimentary relations and the small relational Grzegorczyk classes

Complexity-Theoretic Hierarchies Induced by Fragments of Gödel’s T

\varepsilon^{0}_{*}, \varepsilon^{1}_{*}, \varepsilon^{2}_{*}

Subrecursive degrees and fragments of Peano Arithmetic

attracted fairly much attention during the latter half of the previous century, e.g. Gandy [6], Paris-Wilkie [20], and numerous others.

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

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]).