42 research outputs found
A tier-based typed programming language characterizing Feasible Functionals
The class of Basic Feasible Functionals BFF is the type-2 counterpart of
the class FP of type-1 functions computable in polynomial time. Several
characterizations have been suggested in the literature, but none of these
present a programming language with a type system guaranteeing this complexity
bound. We give a characterization of BFF based on an imperative language
with oracle calls using a tier-based type system whose inference is decidable.
Such a characterization should make it possible to link higher-order complexity
with programming theory. The low complexity (cubic in the size of the program)
of the type inference algorithm contrasts with the intractability of the
aforementioned methods and does not overly constrain the expressive power of
the language
A tier-based typed programming language characterizing Feasible Functionals
The class of Basic Feasible Functionals BFF is the type-2 counterpart of
the class FP of type-1 functions computable in polynomial time. Several
characterizations have been suggested in the literature, but none of these
present a programming language with a type system guaranteeing this complexity
bound. We give a characterization of BFF based on an imperative language
with oracle calls using a tier-based type system whose inference is decidable.
Such a characterization should make it possible to link higher-order complexity
with programming theory. The low complexity (cubic in the size of the program)
of the type inference algorithm contrasts with the intractability of the
aforementioned methods and does not overly constrain the expressive power of
the language
A tier-based typed programming language characterizing Feasible Functionals
International audienceThe class of Basic Feasible Functionals BFF 2 is the type-2 counterpart of the class FP of type-1 functions computable in polynomial time. Several characterizations have been suggested in the literature, but none of these present a programming language with a type system guaranteeing this complexity bound. We give a characterization of BFF 2 based on an imperative language with oracle calls using a tier-based type system whose inference is decidable. Such a characterization should make it possible to link higher-order complexity with programming theory. The low complexity (cubic in the size of the program) of the type inference algorithm contrasts with the intractability of the aforementioned methods and does not restrain strongly the expressive power of the language
Complete and tractable machine-independent characterizations of second-order polytime
The class of Basic Feasible Functionals BFF is the second-order counterpart
of the class of first-order functions computable in polynomial time. We present
several implicit characterizations of BFF based on a typed programming language
of terms. These terms may perform calls to non-recursive imperative procedures.
The type discipline has two layers: the terms follow a standard simply-typed
discipline and the procedures follow a standard tier-based type discipline. BFF
consists exactly of the second-order functionals that are computed by typable
and terminating programs. The completeness of this characterization
surprisingly still holds in the absence of lambda-abstraction. Moreover, the
termination requirement can be specified as a completeness-preserving instance,
which can be decided in time quadratic in the size of the program. As typing is
decidable in polynomial time, we obtain the first tractable (i.e., decidable in
polynomial time), sound, complete, and implicit characterization of BFF, thus
solving a problem opened for more than 20 years
ComplexityParser: An Automatic Tool for Certifying Poly-Time Complexity of Java Programs
International audienceComplexityParser is a static complexity analyzer for Java programs providing the first implementation of a tier-based typing discipline. The input is a file containing Java classes. If the main method can be typed and, provided the program terminates, then the program is guaranteed to do so in polynomial time and hence also to have heap and stack sizes polynomially bounded. The application uses antlr to generate a parse tree on which it performs an efficient type inference: linear in the input size, provided that the method arity is bounded by some constant
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 25th International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2022, which was held during April 4-6, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 23 regular papers presented in this volume were carefully reviewed and selected from 77 submissions. They deal with research on theories and methods to support the analysis, integration, synthesis, transformation, and verification of programs and software systems
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 25th International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2022, which was held during April 4-6, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 23 regular papers presented in this volume were carefully reviewed and selected from 77 submissions. They deal with research on theories and methods to support the analysis, integration, synthesis, transformation, and verification of programs and software systems
Type Systems For Polynomial-time Computation
This thesis introduces and studies a typed lambda calculus with higher-order primitive recursion over inductive datatypes which has the property that all definable number-theoretic functions are polynomial time computable. This is achieved by imposing type-theoretic restrictions on the way results of recursive calls can be used.
The main technical result is the proof of the characteristic property of this system. It proceeds by exhibiting a category-theoretic model in which all morphisms are polynomial time computable by construction.
The second more subtle goal of the thesis is to illustrate the usefulness of this semantic technique as a means for guiding the development of syntactic systems, in particular typed lambda calculi, and to study their meta-theoretic properties.
Minor results are a type checking algorithm for the developed typed lambda calculus and the construction of combinatory algebras consisting of polynomial time algorithms in the style of the first Kleene algebra