56 research outputs found
Theory of higher order interpretations and application to Basic Feasible Functions
Interpretation methods and their restrictions to polynomials have been deeply
used to control the termination and complexity of first-order term rewrite
systems. This paper extends interpretation methods to a pure higher order
functional language. We develop a theory of higher order functions that is
well-suited for the complexity analysis of this programming language. The
interpretation domain is a complete lattice and, consequently, we express
program interpretation in terms of a least fixpoint. As an application, by
bounding interpretations by higher order polynomials, we characterize Basic
Feasible Functions at any order
A Type-Based Complexity Analysis of Object Oriented Programs
A type system is introduced for a generic Object Oriented programming
language in order to infer resource upper bounds. A sound andcomplete
characterization of the set of polynomial time computable functions is
obtained. As a consequence, the heap-space and thestack-space requirements of
typed programs are also bounded polynomially. This type system is inspired by
previous works on ImplicitComputational Complexity, using tiering and
non-interference techniques. The presented methodology has several advantages.
First, itprovides explicit big polynomial upper bounds to the programmer,
hence its use could allow the programmer to avoid memory errors.Second, type
checking is decidable in polynomial time. Last, it has a good expressivity
since it analyzes most object oriented featureslike inheritance, overload,
override and recursion. Moreover it can deal with loops guarded by objects and
can also be extended tostatements that alter the control flow like break or
return.Comment: Information and Computation, Elsevier, A Para\^itre, pp.6
Decidability and Undecidability in Dynamical Systems
A computing system can be modelized in various ways: one being in analogy with transfer functions, this is a function that associates to an input and optionally some internal states, an output ; another being focused on the behaviour of the system, that is describing the sequence of states the system will follow to get from this input to produce the output. This second kind of system can be defined by dynamical systems. They indeed describe the ``local'' behaviour of a system by associating a configuration of the system to the next configuration. It is obviously interesting to get an idea of the ``global'' behaviour of such a dynamical system. The questions that it raises can be for example related to the reachability of a certain configuration or set of configurations or to the computation of the points that will be visited infinitely often. Those questions are unfortunately very complex: they are in most cases undecidable. This article will describe the fundamental problems on dynamical systems and exhibit some results on decidability and undecidability in various kinds of dynamical systems
Algebraic Characterizations of Complexity-Theoretic Classes of Real Functions
Recursive analysis is the most classical approach to model and discuss computations over the reals. It is usually presented using Type 2 or higher order Turing machines. Recently, it has been shown that computability classes of functions computable in recursive analysis can also be defined (or characterized) in an algebraic machine independent way, without resorting to Turing machines. In particular nice connections between the class of computable functions (and some of its sub- and sup-classes) over the reals and algebraically defined (sub- and sup-) classes of -recursive functions Ă la Moore 96 have been obtained. However, until now, this has been done only at the computability level, and not at the complexity level. In this paper we provide a framework that allows us to dive into the complexity level of functions over the reals. In particular we provide the first algebraic characterization of polynomial time computable functions over the reals. This framework opens the field of implicit complexity of functions over the reals, and also provide a new reading of some of the existing characterizations at the computability level
Computing omega-limit Sets in Linear Dynamical Systems
International audienceDynamical systems allow to modelize various phenomena or processes by only describing their local behaviour. It is an important matter to study the global and the limit behaviour of such systems. A possible description of this limit behaviour is via the omega-limit set: the set of points that can be limit of subtrajectories. The omega-limit set is in general uncomputable. It can be a set highly difficult to apprehend. Some systems have for example a fractal omega-limit set. However, in some specific cases, this set can be computed. This problem is important to verify properties of dynamical systems, in particular to predict its collapse or its infinite expansion. We prove in this paper that for linear continuous time dynamical systems, it is in fact computable. More, we also prove that the ω-limit set is a semi-algebraic set. The algorithm to compute this set can easily be derived from this proof
Higher-order interpretations for higher-order complexity
International audienceWe design an interpretation-based theory of higher-order functions that is well-suited for the complexity analysis of a standard higher-order functional language Ă la ml. We manage to express the interpretation of a given program in terms of a least fixpoint and we show that when restricted to functions bounded by higher-order polynomials, they characterize exactly classes of tractable functions known as Basic Feasible Functions at any order
Theory of higher order interpretations and application to Basic Feasible Functions
Interpretation methods and their restrictions to polynomials have been deeply
used to control the termination and complexity of first-order term rewrite
systems. This paper extends interpretation methods to a pure higher order
functional language. We develop a theory of higher order functions that is
well-suited for the complexity analysis of this programming language. The
interpretation domain is a complete lattice and, consequently, we express
program interpretation in terms of a least fixpoint. As an application, by
bounding interpretations by higher order polynomials, we characterize Basic
Feasible Functions at any order
Types for controlling heap and stack in Java
International audienceA type system is introduced for a strict but expressive subset of Java in order to infer resource upper bounds on both the heap-space and the stack-space requirements of typed programs. This type system is inspired by previous works on Implicit Computational Complexity, using tiering and non-interference techniques. The presented methodology has several advantages. First, it provides explicit polynomial upper bounds to the programmer, hence avoiding OutOfMemory and StackOverFlow errors. Second, type checking is decidable in linear time. Last, it has a good expressivity as it analyzes most object oriented features like overload, inheritance, and also handles flow statements controlled by objects
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
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
- …