We investigate the expressive power of the typed -calculus when expressing computations over finite structures, i.e., databases. We show that the simply typed -calculus can express various database query languages such as the relational algebra, fixpoint logic, and the complex object algebra. In our embeddings, inputs and outputs are -terms encoding databases, and a program expressing a query is a -term which types when applied to an input and reduces to an output.

We consider evaluation strategies for database queries expressed in three functional query languages: the complex value algebra, the simply typed lambda calculus, and method schemas. Each of these query languages derives its expressive power from a different primitive: the complex value algebra from the powerset operator, the simply typed lambda calculus from list iteration, and method schemas from recursion. We show that "natural" evaluation strategies for these primitives may lead to very inefficient space usage, but that with some simple optimizations many queries can be evaluated with little or no space overhead. In particular, we show: (1) In the complex value algebra, all expressions with set nesting depth at most 2 can be evaluated in pspace, and this set of expressions is sufficient to express all queries in the polynomial hierarchy; (2) In the simply typed lambda calculus with equality and constants, all query terms of order at most 5 (where "query term" is a syntactic condition on types) can be evaluated in pspace, and this set of terms expresses exactly the pspace queries; (3) There exists a set of second-order method schemas (with no simple syntactic characterization) that can be evaluated in pspace, and this set of schemas is sufficient to express all pspace queries.

Church's simply typed -calculus is a very basic framework for functional programming language research. However, it is common to augment this framework with additional programming constructs, because its expressive power for functions over the domain of Church numerals is very limited. In this thesis: (1) We re-examine the expressive power of the "pure" simply typed -calculus, but over encodings of finite relational structures, i. e., finite models or databases . In this novel framework the simply typed -calculus expresses all elementary functions from finite models to finite models. In addition, many common database query languages, e. g., relational algebra, Datalog : , and the Abiteboul/Beeri complex object algebra, can be embedded into it. The embeddings are feasible in the sense that the -terms corresponding to PTIME queries can be evaluated in polynomial time. (2) We examine fixed-order fragments of the simply typed -calculus to determine machine independent characterizations of complexity classes. For this we augment the calculus with atomic constants and equality among atomic constants. We show that over ordered structures, the order 3, 4, 5, and 6 fragments express exactly the first-order, PTIME, PSPACE, and EXPTIME queries, respectively, and we conjecture that for general k 1, order 2 k + 4 expresses exactly the k-EXPTIME queries and order 2 k + 5 expresses exactly the k-EXPSPACE queries. (3) We also re-examine other functional characterizations of PTIME and we show that method schemas with ordered objects express exactly PTIME. This is a first-order framework proposed for object-oriented databases---as opposed to the above higher-order frameworks. In summary, this research provides a link between finite model theory (and thus computational complexity), dat...

Core-ML is a basic subset of most functional programming languages. It consists of the simply typed (or monomorphic) -calculus, simply typed equality over atomic constants, and let as the only polymorphic construct. We present a synthesis of recent results which characterize this "toy" language's expressive power as well as its type reconstruction (or type inference) problem. More specifically: (1) Core-ML can express exactly the ELEMENTARY queries, where a program input is a database encoded as a -term and a query program is a -term whose application to the input normalizes to the output database. In addition, it is possible to express all the PTIME queries so that this normalization process is polynomial in the input size. (2) The polymorphism of let can be explained using a simple algorithmic reduction to monomorphism, and provides flexibility, without affecting expressibility. Algorithms for type reconstruction offer the additional convenience of static typing without type declarations. Given polymorphism, the price of this convenience is an increase in complexity from linear-time in the size of the program typed (without let) to completeness in exponential-time (with let).

We present a functional framework for descriptive computational complexity, in which the Regular, Firstorder, Ptime, Pspace, k-Exptime, k-Expspace (k 1), and Elementary sets have syntactic characterizations. In this framework, typed lambda terms represent inputs and outputs as well as programs. The lambda calculi describing the above computational complexity classes are simply or let-polymorphically typed with functionalities of fixed order. They consist of: order 0 atomic constants, order 1 equality among these constants, variables, application, and abstraction. Increasing functionality order by one for these languages corresponds to increasing the computational complexity by one alternation. This exact correspondence is established using a semantic evaluation of languages for each fixed order, which is the primary technical contribution of this paper.

This is a collection of some more or less chaotic remarks on the ML type system, definitely not sufficient to fill a research paper of reasonable quality, but perhaps interesting enough to be written down as a note. At the beginning the idea was to investigate the complexity of type reconstruction and typability in bounded order fragments of ML. Unexpectedly the problem turned out to be hard, and finally I obtained only partial results. I do not feel like spending more time on this topic, so the text is not polished, the proofs --- if included at all --- are only sketched and of rather poor mathematical quality. I believe however, that some remarks, especially those of "philosophical" nature, shed some light on the ML type system and may be of some value to the reader interested especially in the interaction between theory and practice of ML type reconstruction. 1 Introduction The ML type system was developed by Robin Milner in the late seventies [26, 3], but was influenced by much ol...

Searching for a better data model would continue unless a satisfaction was reached. Improving the productivity and quality of developing traditional and emerging database applications is the motivation driving the research activities. This abstract is to introduce the approach of a data model- EP data model. Its data structure is able to store as a finite set of nodes arbitrary effectively computable functions. Its queries are arbitrary computable functions. Both the data structure and the queries of the EP data model are unified under an extended lambda caculus, which provides a uniform manner to access data (either finite or infinite). Expressiveness and Descriptiveness The less implementation details developers have to deal with,

We investigate a higher-order query language that embeds operators of the positive relational algebra within the simply-typed λ-calculus. Our language allows one to succinctly define ordinary positive relational algebra queries (conjunctive queries and unions of conjunctive queries) and, in addition, second-order query functionals, which allow the transformation of CQs and UCQs in a generic (i.e., syntaxindependent) way. We investigate the equivalence and containment problems for this calculus, which subsumes traditional CQ/UCQ containment. Query functionals are said to be equivalent if the output queries are equivalent, for each possible input query, and similarly for containment. These notions of containment and equivalence depend on the class of (ordinary relational algebra) queries considered. We show that containment and equivalence are decidable when query variables are restricted to positive relational algebra and we identify the precise complexity of the problem. We also identify classes of functionals where containment is tractable. Finally, we provide upper bounds to the complexity of the containment problem when functionals act over other classes.

this technical obituary feel honored by the privilege they had in collaborating with Paris on many of these projects. In mourning his tragic death, we miss his technical facility, his broad knowledge, his insight, his commitment, and his humor. To write a research paper with Paris was also an opportunity to observe his indefatigable attention to detail, and to engage in vigorous debate with his editorial voice. To write this obituary allowed us to to feel his voice once more, to understand better what a good scientist he was, and to appreciate his uncommon decency and kindness. It is our great loss that we will not hear his voice again. 1 Deductive Databases

The contribution of this paper is three-fold: 1) We analyze expressiveness of the simply typed lambda calculus (STLC) over a single base type, and show how k-DEXPTIME computations can be simulated in the order k + 6 STLC. This gives a double order improvement over the lower bound of (Hillebrand & Kanellakis 1996), reducing k-DEXPTIME to the order 2k + 3 STLC. ...