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.

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 N of natural numbers we have combined the LISP-like simplicity of coding with the simplicity of semantics. We deal just with functions over N 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.

this paper is to investigate the impact on the design of a programming language of tight integration of a language processor with a theorem prover (intelligent proof assistant). What improvements in syntax, semantics, and computation do we gain by this? We assume as self-evident the obvious gain which is quite substantial. The language obtains a sound semantics by its interpretation into a formal logical theory. By proving theorems about our programs we can prove them correct. From the many language systems with theorem provers we mention just two: PVS and Isabelle/HOL [6, 5]. Both of them are more general theorem provers than programming languages. On the other hand, our system CL (Clausal Language) , has been designed as a programming language from the start. It is not a language which can be used for industrial applications (yet, we hope), but neither is it a toy language. It has been used in our undergraduate teaching for seven years now. About four hundred students yearly actively use it in the four courses based on CL [2]. While, the formal basis for PVS and Isabelle is high order logic with typed functionals, CL is based on the simplest non-trivial formal theory: Peano Arithmetic (PA)

) Paul J. Voda, J'an Komara Institute of Informatics, Comenius University Bratislava, Mlynsk'a dolina, 842 43 Bratislava, Slovakia. Email: voda@fmph.uniba.sk, komara@fmph.uniba.sk Abstract: This paper is an extended abstract of parts I and II of a monograph with the same title being prepared by the authors. Logic was developed before the arrival of computers and it can be presented without reference to them. The main idea of the monograph is to stress the mutual links between logic and computer programming by taking those parts of logic which deal with computability and finitary logic (proof theory) and presenting them by employing the techniques of computer programming. The techniques involve the use of a good programming language with good data structures and proving the properties of functions written in this language. Keywords: computability, logic, computer programming 1 Introduction Nobody disputes the importance of mathematical logic to computer science but the influence...

37> n= j & Priorities (decreasing): (&) (n=) (!\Gamma? \Gamma?). All connectives are right associative. Rel ::= = j ! = j ! j != j ? j ?= j in j !in Op ::= + j \Gamma j j = j mod j ++ Priorities (decreasing): ( = mod) (+ \Gamma ++). Left associative: = mod + \Gamma ++ . Var Examples: i, x, zs, maximal number of the list. Ident Examples: Fib, Maximal number, N, Expr2string, Born 1 jan 1997. Num Examples: 1, 2, 1997, 12345678901234567890. Char Examples: "a", "Z", "9", "!",<F11.81

. C lausal Language (CL) is a really used declarative programming and verifying system with an extremely simple semantics (primitive recursive functions). We can in CL prove properties of our programs. This paper is mostly concerned with the combination of programming and verication where one does the former at the same time as one veri- es that a specication is satised. Our contribution is the design of CL and of its proof system where the programming constructs correspond exactly to the proof rules with computational content and so the programs extracted by CL from proofs are as ecient as hand-programmed ones. 1 Introduction The class of eectively computable functions over natural numbers coincides by the thesis of Church with recursive functions as dened by Herbrand-Godel style equations. We use the latter as the basis for CL because such denitions oer the programming comfort with almost unrestricted kinds of recursion and the computation of recursive equations b...

C lausal Language (CL) is a declarative programming and verifying system used in our teaching of computer science. CL is an implementation of, what we call, PR+I1 paradigm (primitive recursive functions with I1-arithmetic). This paper introduces an extension of I1-proofs called extraction proofs where one can extract from the proofs of 2-speci cations primitive recursive programs as ecient as the hand-coded ones. This is achieved by having the programming constructs correspond exactly to the proof rules with the computational content.