On the sequential nature of unification
Journal of Logic Programming
Partial polymorphic type inference and higher-order unification
LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Proofs and types
Polymorphic unification and ML typing
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Structure and Interpretation of Computer Programs
Structure and Interpretation of Computer Programs
Introduction To Automata Theory, Languages, And Computation
Introduction To Automata Theory, Languages, And Computation
The Design and Analysis of Computer Algorithms
The Design and Analysis of Computer Algorithms
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
The complexity of type inference for higher-order lambda calculi
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Algebraic reconstruction of types and effects
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Object-oriented type inference
OOPSLA '91 Conference proceedings on Object-oriented programming systems, languages, and applications
Automatic instantiation in Ada
TRI-Ada '91 Proceedings of the conference on TRI-Ada '91: today's accomplishments; tomorrow's expectations
Dynamic program parallelization
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Lively linear Lisp: “look ma, no garbage!”
ACM SIGPLAN Notices
Fips: a functional-imperative language for explorative programming
ACM SIGPLAN Notices
Type inference with polymorphic recursion
ACM Transactions on Programming Languages and Systems (TOPLAS)
Journal of the ACM (JACM)
The Boyer benchmark meets linear logic
ACM SIGPLAN Lisp Pointers
Garbage collection for strongly-typed languages using run-time type reconstruction
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
What are principal typings and what are they good for?
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Implementing typed intermediate languages
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Relating typability and expressiveness in finite-rank intersection type systems (extended abstract)
Proceedings of the fourth ACM SIGPLAN international conference on Functional programming
Dependency analysis for Standard ML
ACM Transactions on Programming Languages and Systems (TOPLAS)
Predicate Subtyping with Predicate Sets
TPHOLs '01 Proceedings of the 14th International Conference on Theorem Proving in Higher Order Logics
Mathematical Structures in Computer Science
PPDP '04 Proceedings of the 6th ACM SIGPLAN international conference on Principles and practice of declarative programming
Types, potency, and idempotency: why nonlinearity and amnesia make a type system work
Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
Relating complexity and precision in control flow analysis
ICFP '07 Proceedings of the 12th ACM SIGPLAN international conference on Functional programming
Efficient type inference using ranked type variables
ML '07 Proceedings of the 2007 workshop on Workshop on ML
Polymorphic type inference for the named nested relational calculus
ACM Transactions on Computational Logic (TOCL)
Deciding kCFA is complete for EXPTIME
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Existential Type Systems with No Types in Terms
TLCA '09 Proceedings of the 9th International Conference on Typed Lambda Calculi and Applications
A logical algorithm for ML type inference
RTA'03 Proceedings of the 14th international conference on Rewriting techniques and applications
Model Checking Higher-Order Programs
Journal of the ACM (JACM)
Hi-index | 0.00 |
A well known but incorrect piece of functional programming folklore is that ML expressions can be efficiently typed in polynomial time. In probing the truth of that folklore, various researchers, including Wand, Buneman, Kanellakis, and Mitchell, constructed simple counterexamples consisting of typable ML programs having length n, with principal types having &OHgr;(2cn) distinct type variables and length &OHgr;(22cn). When the types associated with these ML constructions were represented as directed acyclic graphs, their sizes grew as &OHgr;(2cn). The folklore was even more strongly contradicted by the recent result of Kanellakis and Mitchell that simply deciding whether or not an ML expression is typable is PSPACE-hard.We improve the latter result, showing that deciding ML typability is DEXPTIME-hard. As Kanellakis and Mitchell have shown containment in DEXPTIME, the problem is DEXPTIME-complete. The proof of DEXPTIME-hardness is carried out via a generic reduction: it consists of a very straightforward simulation of any deterministic one-tape Turing machine M with input &khgr; running in &Ogr;(c|&khgr;|) time by a polynomial-sized ML formula &PHgr;M,&khgr;, such that M accepts &khgr; iff &PHgr;M,&khgr; is typable. The simulation of the transition function &dgr; of the Turing Machine is realized uniquely through terms in the lambda calculus without the use of the polymorphic let construct. We use let for two purposes only: to generate an exponential amount of blank tape for the Turing Machine simulation to begin, and to compose an exponential number of applications of the ML formula simulating state transition.It is purely the expressive power of ML polymorphism to succinctly express function composition which results in a proof of DEXPTIME-hardness. We conjecture that lower bounds on deciding typability for extensions to the typed lambda calculus can be regarded precisely in terms of this expressive capacity for succinct function composition.To further understand this lower bound, we relate it to the problem of proving equality of type variables in a system of type equations generated from an ML expression with let-polymorphism. We show that given an oracle for solving this problem, deciding typability would be in PSPACE, as would be the actual computation of the principal type of the expression, were it indeed typable.