Results 1  10
of
21
The complexity of type inference for higherorder typed lambda calculi
 In. Proc. 18th ACM Symposium on the Principles of Programming Languages
, 1991
"... We analyse the computational complexity of type inference for untyped X,terms in the secondorder polymorphic typed Xcalculus (F2) invented by Girard and Reynolds, as well as higherorder extensions F3,F4,...,/ ^ proposed by Girard. We prove that recognising the i^typable terms requires exponential ..."
Abstract

Cited by 28 (11 self)
 Add to MetaCart
We analyse the computational complexity of type inference for untyped X,terms in the secondorder polymorphic typed Xcalculus (F2) invented by Girard and Reynolds, as well as higherorder extensions F3,F4,...,/ ^ proposed by Girard. We prove that recognising the i^typable terms requires exponential time, and for Fa the problem is nonelementary. We show as well a sequence of lower bounds on recognising the i^typable terms, where the bound for Fk+1 is exponentially larger than that for Fk. The lower bounds are based on generic simulation of Turing Machines, where computation is simulated at the expression and type level simultaneously. Nonaccepting computations are mapped to nonnormalising reduction sequences, and hence nontypable terms. The accepting computations are mapped to typable terms, where higherorder types encode reduction sequences, and firstorder types encode the entire computation as a circuit, based on a unification simulation of Boolean logic. A primary technical tool in this reduction is the composition of polymorphic functions having different domains and ranges. These results are the first nontrivial lower bounds on type inference for the Girard/Reynolds
Database Query Languages Embedded in the Typed Lambda Calculus
, 1993
"... 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 ..."
Abstract

Cited by 25 (6 self)
 Add to MetaCart
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.
Relating Typability and Expressiveness in FiniteRank Intersection Type Systems (Extended Abstract)
 In Proc. 1999 Int’l Conf. Functional Programming
, 1999
"... We investigate finiterank intersection type systems, analyzing the complexity of their type inference problems and their relation to the problem of recognizing semantically equivalent terms. Intersection types allow something of type T1 /\ T2 to be used in some places at type T1 and in other places ..."
Abstract

Cited by 21 (9 self)
 Add to MetaCart
We investigate finiterank intersection type systems, analyzing the complexity of their type inference problems and their relation to the problem of recognizing semantically equivalent terms. Intersection types allow something of type T1 /\ T2 to be used in some places at type T1 and in other places at type T2 . A finiterank intersection type system bounds how deeply the /\ can appear in type expressions. Such type systems enjoy strong normalization, subject reduction, and computable type inference, and they support a pragmatics for implementing parametric polymorphism. As a consequence, they provide a conceptually simple and tractable alternative to the impredicative polymorphism of System F and its extensions, while typing many more programs than the HindleyMilner type system found in ML and Haskell. While type inference is computable at every rank, we show that its complexity grows exponentially as rank increases. Let K(0, n) = n and K(t + 1, n) = 2^K(t,n); we prove that recognizing the pure lambdaterms of size n that are typable at rank k is complete for dtime[K(k1, n)]. We then consider the problem of deciding whether two lambdaterms typable at rank k have the same normal form, Generalizing a wellknown result of Statman from simple types to finiterank intersection types. ...
A simple proof of a theorem of Statman
 Theoretical Computer Science
, 1992
"... In this note, we reprove a theorem of Statman that deciding the fijequality of two firstorder typable terms is not elementary recursive [Sta79]. The basic idea of our proof, like that of Statman's, is the Henkin quantifier elimination procedure [Hen63]. However, our coding is much simpler, an ..."
Abstract

Cited by 20 (5 self)
 Add to MetaCart
In this note, we reprove a theorem of Statman that deciding the fijequality of two firstorder typable terms is not elementary recursive [Sta79]. The basic idea of our proof, like that of Statman's, is the Henkin quantifier elimination procedure [Hen63]. However, our coding is much simpler, and easy to understand. 1 Introduction A well known theorem of Richard Statman states that if we have two terms that are firstorder typable, deciding whether the terms reduce to the same normal form is not Kalmar elementary: namely, it cannot be decided in f k (n) steps for any fixed integer k 0, where n is the length of the two terms, and f 0 (n) = n, f t+1 (n) = 2 f t (n) . The theorem is often cited, but in contrast, its proof is not well understood. In this note, we give a simple proof of the theorem. The key idea that vastly simplifies the technical details of the proof is to use list iteration as a quantifier elimination procedure. 2 Preliminaries 2.1 Deciding truth of formulas in high...
Complexity of Nonrecursive Logic Programs with Complex Values
 In Proceedings of the 17th ACM SIGACTSIGMODSIGART Symposium on Principles of Database Systems (PODS’98
, 1998
"... We investigate complexity of the SUCCESS problem for logic query languages with complex values: check whether a query defines a nonempty set. The SUCCESS problem for recursive query languages with complex values is undecidable, so we study the complexity of nonrecursive queries. By complex values we ..."
Abstract

Cited by 15 (2 self)
 Add to MetaCart
We investigate complexity of the SUCCESS problem for logic query languages with complex values: check whether a query defines a nonempty set. The SUCCESS problem for recursive query languages with complex values is undecidable, so we study the complexity of nonrecursive queries. By complex values we understand values such as trees, finite sets, and multisets. Due to the wellknown correspondence between relational query languages and datalog, our results can be considered as results about relational query languages with complex values. The paper gives a complete complexity classification of the SUCCESS problem for nonrecursive logic programs over trees depending on the underlying signature, presence of negation, and range restrictedness. We also prove several results about finite sets and multisets. 1 Introduction A number of complexity results have been established for logic query languages. They are surveyed in [49, 18]. The major themes in these results are the complexity and expr...
Functional Database Query Languages as Typed Lambda Calculi of Fixed Order (Extended Abstract)
 In Proceedings 13th PODS
, 1994
"... We present a functional framework for database query languages, which is analogous to the conventional logical framework of firstorder and fixpoint formulas over finite structures. We use atomic constants of order 0, equality among these constants, variables, application, lambda abstraction, and le ..."
Abstract

Cited by 12 (5 self)
 Add to MetaCart
We present a functional framework for database query languages, which is analogous to the conventional logical framework of firstorder and fixpoint formulas over finite structures. We use atomic constants of order 0, equality among these constants, variables, application, lambda abstraction, and let abstraction; all typed using fixed order ( 5) functionalities. In this framework, proposed in [21] for arbitrary order functionalities, queries and databases are both typed lambda terms, evaluation is by reduction, and the main programming technique is list iteration. We define two families of languages: TLI = i or simplytyped list iteration of order i +3 with equality, and MLI = i or MLtyped list iteration of order i+3 with equality; we use i+3 since our list representation of databases requires at least order 3. We show that: FOqueries ` TLI = 0 ` MLI = 0 ` LOGSPACEqueries ` TLI = 1 = MLI = 1 = PTIMEqueries ` TLI = 2 , where equality is no longer a primitive in TLI = 2 . We also show that ML type inference, restricted to fixed order, is polynomial in the size of the program typed. Since programming by using low order functionalities and type inference is common in functional languages, our results indicate that such programs suffice for expressing efficient computations and that their MLtypes can be efficiently inferred.
The "Hardest" Natural Decidable Theory
 12th Annual IEEE Symp. on Logic in Computer Science (LICS'97)', IEEE
, 1997
"... We prove that any decision procedure for a modest fragment of L. Henkin's theory of pure propositional types [7, 12, 15, 11] requires time exceeding a tower of 2's of height exponential in the length of input. Until now the highest known lower bounds for natural decidable theories were at ..."
Abstract

Cited by 10 (4 self)
 Add to MetaCart
We prove that any decision procedure for a modest fragment of L. Henkin's theory of pure propositional types [7, 12, 15, 11] requires time exceeding a tower of 2's of height exponential in the length of input. Until now the highest known lower bounds for natural decidable theories were at most linearly high towers of 2's and since midseventies it was an open problem whether natural decidable theories requiring more than that exist [12, 2]. We give the affirmative answer. As an application of this today's strongest lower bound we improve known and settle new lower bounds for several problems in the simply typed lambda calculus. 1. Introduction In his survey paper [12] A. Meyer mentioned (p. 479), as a curious empirical observation, that all known natural decidable nonelementary problems require at most (upper bound) F (1; n) = exp 1 (n) = 2 2 \Delta \Delta \Delta 2 oe n Turing machine steps on inputs of length n to decide 1 . Until now the highest known lower bounds for natu...
Finite Model Theory In The Simply Typed Lambda Calculus
, 1994
"... 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 ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
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 reexamine 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 fixedorder 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 firstorder, PTIME, PSPACE, and EXPTIME queries, respectively, and we conjecture that for general k 1, order 2 k + 4 expresses exactly the kEXPTIME queries and order 2 k + 5 expresses exactly the kEXPSPACE queries. (3) We also reexamine other functional characterizations of PTIME and we show that method schemas with ordered objects express exactly PTIME. This is a firstorder framework proposed for objectoriented databasesas opposed to the above higherorder frameworks. In summary, this research provides a link between finite model theory (and thus computational complexity), dat...
Optimal) duplication is not elementary recursive
 In Proceedings of the 27th ACM SIGPLANSIGACT Symposium on Principles of Programming Languages (POLP00
, 2000
"... In 1998 Asperti and Mairson proved that the cost of reducing a lambdaterm using an optimal lambdareducer (a la Lévy) cannot be bound by any elementary function in the number of sharedbeta steps. We prove in this paper that an analogous result holds for Lamping’s abstract algorithm. That is, there ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
In 1998 Asperti and Mairson proved that the cost of reducing a lambdaterm using an optimal lambdareducer (a la Lévy) cannot be bound by any elementary function in the number of sharedbeta steps. We prove in this paper that an analogous result holds for Lamping’s abstract algorithm. That is, there is no elementary function in the number of shared beta steps bounding the number of duplication steps of the optimal reducer. This theorem vindicates the oracle of Lamping’s algorithm as the culprit for the negative result of Asperti and Mairson. The result is obtained using as a technical tool Elementary Affine Logic. Key words: complexity, elementary affine logic, graph rewriting, optimal reduction
On the expressive power of simply typed and letpolymorphic lambda calculi
 11th Annual IEEE Symp. on Logic in Computer Science (LICS'96)
, 1996
"... We present a functional framework for descriptive computational complexity, in which the Regular, Firstorder, Ptime, Pspace, kExptime, kExpspace (k 1), and Elementary sets have syntactic characterizations. In this framework, typed lambda terms represent inputs and outputs as well as programs. The ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
We present a functional framework for descriptive computational complexity, in which the Regular, Firstorder, Ptime, Pspace, kExptime, kExpspace (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 letpolymorphically 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.