Proofs and types
Descriptive characterizations of computational complexity
Journal of Computer and System Sciences
On the expressive power of finitely typed and universally polymorphic recursive procedures
Theoretical Computer Science
Characterizing complexity classes by higher type primitive recursive definitions
Theoretical Computer Science
The formal semantics of programming languages: an introduction
The formal semantics of programming languages: an introduction
Characterizing complexity classes by general recursive definitions in higher types
Information and Computation
Lambda calculus characterizations of poly-time
Fundamenta Informaticae - Special issue: lambda calculus and type theory
A new recursion-theoretic characterization of the polytime functions
Computational Complexity
Finite model theory in the simply typed lambda calculus
Finite model theory in the simply typed lambda calculus
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Computability and complexity: from a programming perspective
Computability and complexity: from a programming perspective
LOGSPACE and PTIME characterized by programming languages
Theoretical Computer Science - Special issue on mathematical foundations of programming semantics
Characterizations of Pushdown Machines in Terms of Time-Bounded Computers
Journal of the ACM (JACM)
Elementary Strong Functional Programming
FPLE '95 Proceedings of the First International Symposium on Functional Programming Languages in Education
Characterizing Complexity Classes by Higher Type Primitive Recursive Definitions, Part II
Proceedings of the 6th International Meeting of Young Computer Scientists on Aspects and Prospects of Theoretical Computer Science
Recursion Versus Iteration at Higher-Orders
Proceedings of the 17th Conference on Foundations of Software Technology and Theoretical Computer Science
Subrecursion as a Basis for a Feasible Programming Language
CSL '94 Selected Papers from the 8th International Workshop on Computer Science Logic
A Simple Ordinal Recursive Normalization of Gödel's T
CSL '97 Selected Papers from the11th International Workshop on Computer Science Logic
Applicative Control and Computational Complexity
CSL '99 Proceedings of the 13th International Workshop and 8th Annual Conference of the EACSL on Computer Science Logic
On the Expressive Power of Simply Typed and Let-Polymorphic Lambda Calculi
LICS '96 Proceedings of the 11th Annual IEEE Symposium on Logic in Computer Science
A tutorial on the universality and expressiveness of fold
Journal of Functional Programming
More haste, less speed: lazy versus eager evaluation
Journal of Functional Programming
From recursion to iteration: what are the optimizations?
PEPM '00 Proceedings of the 2000 ACM SIGPLAN workshop on Partial evaluation and semantics-based program manipulation
The strength of non-size increasing computation
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A syntactical analysis of non-size-increasing polynomial time computation
ACM Transactions on Computational Logic (TOCL)
The Strength of Non-size-increasing Computation (Introduction and Summary)
MFCS '01 Proceedings of the 26th International Symposium on Mathematical Foundations of Computer Science
A Statically Allocated Parallel Functional Language
ICALP '00 Proceedings of the 27th International Colloquium on Automata, Languages and Programming
On Lexicographic Termination Ordering with Space Bound Certifications
PSI '02 Revised Papers from the 4th International Andrei Ershov Memorial Conference on Perspectives of System Informatics: Akademgorodok, Novosibirsk, Russia
The essence of computation
Complexity classes and fragments of C
Information Processing Letters
Programming languages capturing complexity classes
Nordic Journal of Computing
Implicit complexity over an arbitrary structure: quantifier alternations
Information and Computation
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Time-Complexity Semantics for Feasible Affine Recursions
CiE '07 Proceedings of the 3rd conference on Computability in Europe: Computation and Logic in the Real World
Pure Iteration and Periodicity
CiE '08 Proceedings of the 4th conference on Computability in Europe: Logic and Theory of Algorithms
Recursion in Higher Types and Resource Bounded Turing Machines
CiE '08 Proceedings of the 4th conference on Computability in Europe: Logic and Theory of Algorithms
A flow calculus of mwp-bounds for complexity analysis
ACM Transactions on Computational Logic (TOCL)
ACM Transactions on Computational Logic (TOCL)
Implicit complexity over an arbitrary structure: Quantifier alternations
Information and Computation
A characterisation of the relations definable in Presburger arithmetic
TAMC'08 Proceedings of the 5th international conference on Theory and applications of models of computation
Bounded minimalisation and bounded counting in argument-bounded idc's
Mathematical Structures in Computer Science
Complexity-Theoretic hierarchies
CiE'06 Proceedings of the Second conference on Computability in Europe: logical Approaches to Computational Barriers
An Implicit Characterization of PSPACE
ACM Transactions on Computational Logic (TOCL)
The small grzegorczyk classes and the typed λ-calculus
CiE'05 Proceedings of the First international conference on Computability in Europe: new Computational Paradigms
The flow of data and the complexity of algorithms
CiE'05 Proceedings of the First international conference on Computability in Europe: new Computational Paradigms
Elementary linear logic revisited for polynomial time and an exponential time hierarchy
APLAS'11 Proceedings of the 9th Asian conference on Programming Languages and Systems
Type-Based complexity analysis for fork processes
FOSSACS'13 Proceedings of the 16th international conference on Foundations of Software Science and Computation Structures
Hi-index | 0.00 |
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.