Compare first-order functional programs with higher-order programs allowing functions as function parameters. Can the the first program class solve fewer problems than the second? The answer is no: both classes are Turing complete, meaning that they can compute all partial recursive functions. In particular, higher-order values may be first-order simulated by use of the list constructor ‘cons’ to build function closures. This paper uses complexity theory to prove some expressivity results about small programming languages that are less than Turing complete. Complexity classes of decision problems are used to characterize the expressive power of functional programming language features. An example: second-order programs are more powerful than first-order, since a function f of type [Bool]-〉Bool is computable by a cons-free first-order functional program if and only if f is in PTIME, whereas f is computable by a cons-free second-order program if and only if f is in EXPTIME. Exact characterizations are given for those problems of type [Bool]-〉Bool solvable by programs with several combinations of operations on data: presence or absence of constructors; the order of data values: 0, 1, or higher; and program control structures: general recursion, tail recursion, primitive recursion.

We demonstrate that the class of rst order functional programs over lists which terminate by multiset path ordering and admit a polynomial quasi-interpretation, is exactly the class of function computable in polynomial time. The interest of this result lies (i) on the simplicity of the conditions on programs to certify their complexity, (ii) on the fact that an important class of natural programs is captured, (iii) and on potential applications on program optimizations. 1 Introduction This paper is part of a general investigation on the implicit complexity of a specication. To illustrate what we mean, we write below the recursive rules that computes the longest common subsequences of two words. More precisely, given two strings u = u1 um and v = v1 vn of f0; 1g , a common subsequence of length k is dened by two sequences of indices i 1 < < i k and j1 < < jk satisfying u i q = v j q . lcs(; y) ! 0 lcs(x; ) ! 0 lcs(i(x); i(y)) ! lcs(x; y) + 1 lcs(i(...

We present a method for certifying that the values computed by an imperative program will be bounded by polynomials in the program’s inputs. To this end, we introduce mwp-matrices and define a semantic relation | = C: M where C is a program and M is an mwp-matrix. It follows straightforwardly from our definitions that there exists M such that | = C:M 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:M to hold iff there exists a derivation in the calculus where C:M is the bottom line. We prove that ⊢ C:M implies | = C:M. By means of exhaustive proof search, an algorithm can decide if there exists M such that the relation ⊢ C:M holds, and thus, our results yield a computational method. Categories and Subject Descriptors: D.2.4 [Software engineering]: Software/Program Verification; F.2.0 [Analysis of algorithms and problem complexity]: General; F.3.1 [Logics and meanings of programs]: Specifying and Verifying and Reasoning about Programs

We give two simple uniform characterizations of the complexity classes L NL P NP by register machine programs. Both characterizations are intrinsic because they do not refer to any time and space bounds. The rst characterization, which permits programs to peek into their computation history, captures also Pspace and it is completely syntactical in that the restrictions on programs are decided from their syntax. The programs computing predicates of larger classes are permitted to access larger parts of their history. The second characterization restricts the access of programs to parts of their input which are then projected away by existential quantication. 1

This paper provides a recursion-theoretic characterization of the functions computable in logarithmic space, without explicit bounds in the recursion schemes. It can be seen as a variation of the Clote and Takeuti characterization of logspace functions [7], which results from the implementation of an intrinsic growth-control within an inputsorted context.

In this paper, we show that the Bellantoni and Cook characterization of polynomial time computable functions in term of safe recursive functions can be transfered to the model of computation over an arbitrary structure developped by L. Blum, M. Shub and S. Smale.

k / peo pl e/N DJ.h tml Abstract. A programming approac h to computabilit y and complexit y theory yields pro ofs of cen tral results that are sometimes more natural than the classical ones; and some new results as w ell.

f(0, y) = g(y) f(x + 1, y) = h(x, y, f(j1(x), y),..., f(jk(x), y) where g, h, j1,..., jk are primitive recursive and ji(x) ≤ x for i ∈ {1,..., k} , are themselves primitive recursive. A similar remark holds for recursion with parameter substituhal-00642731,