28 research outputs found
Complexity Information Flow in a Multi-threaded Imperative Language
We propose a type system to analyze the time consumed by multi-threaded
imperative programs with a shared global memory, which delineates a class of
safe multi-threaded programs. We demonstrate that a safe multi-threaded program
runs in polynomial time if (i) it is strongly terminating wrt a
non-deterministic scheduling policy or (ii) it terminates wrt a deterministic
and quiet scheduling policy. As a consequence, we also characterize the set of
polynomial time functions. The type system presented is based on the
fundamental notion of data tiering, which is central in implicit computational
complexity. It regulates the information flow in a computation. This aspect is
interesting in that the type system bears a resemblance to typed based
information flow analysis and notions of non-interference. As far as we know,
this is the first characterization by a type system of polynomial time
multi-threaded programs
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
Complexity Hierarchies and Higher-order Cons-free Term Rewriting
Constructor rewriting systems are said to be cons-free if, roughly,
constructor terms in the right-hand sides of rules are subterms of the
left-hand sides; the computational intuition is that rules cannot build new
data structures. In programming language research, cons-free languages have
been used to characterize hierarchies of computational complexity classes; in
term rewriting, cons-free first-order TRSs have been used to characterize the
class PTIME.
We investigate cons-free higher-order term rewriting systems, the complexity
classes they characterize, and how these depend on the type order of the
systems. We prove that, for every K 1, left-linear cons-free systems
with type order K characterize ETIME if unrestricted evaluation is used
(i.e., the system does not have a fixed reduction strategy).
The main difference with prior work in implicit complexity is that (i) our
results hold for non-orthogonal term rewriting systems with no assumptions on
reduction strategy, (ii) we consequently obtain much larger classes for each
type order (ETIME versus EXPTIME), and (iii) results for cons-free
term rewriting systems have previously only been obtained for K = 1, and with
additional syntactic restrictions besides cons-freeness and left-linearity.
Our results are among the first implicit characterizations of the hierarchy E
= ETIME ETIME ... Our work confirms prior
results that having full non-determinism (via overlapping rules) does not
directly allow for characterization of non-deterministic complexity classes
like NE. We also show that non-determinism makes the classes characterized
highly sensitive to minor syntactic changes like admitting product types or
non-left-linear rules.Comment: extended version of a paper submitted to FSCD 2016. arXiv admin note:
substantial text overlap with arXiv:1604.0893
Complexity Hierarchies and Higher-Order Cons-Free Rewriting
Constructor rewriting systems are said to be cons-free if, roughly,
constructor terms in the right-hand sides of rules are subterms of constructor
terms in the left-hand side; the computational intuition is that rules cannot
build new data structures. It is well-known that cons-free programming
languages can be used to characterize computational complexity classes, and
that cons-free first-order term rewriting can be used to characterize the set
of polynomial-time decidable sets.
We investigate cons-free higher-order term rewriting systems, the complexity
classes they characterize, and how these depend on the order of the types used
in the systems. We prove that, for every k 1, left-linear cons-free
systems with type order k characterize ETIME if arbitrary evaluation is
used (i.e., the system does not have a fixed reduction strategy).
The main difference with prior work in implicit complexity is that (i) our
results hold for non-orthogonal term rewriting systems with possible rule
overlaps with no assumptions about reduction strategy, (ii) results for such
term rewriting systems have previously only been obtained for k = 1, and with
additional syntactic restrictions on top of cons-freeness and left-linearity.
Our results are apparently among the first implicit characterizations of the
hierarchy E = ETIME ETIME .... Our work
confirms prior results that having full non-determinism (via overlaps of rules)
does not directly allow characterization of non-deterministic complexity
classes like NE. We also show that non-determinism makes the classes
characterized highly sensitive to minor syntactic changes such as admitting
product types or non-left-linear rules.Comment: Extended version (with appendices) of a paper published in FSCD 201
The Expressive Power of One Variable Used Once: The Chomsky Hierarchy and First-Order Monadic Constructor Rewriting
We study the implicit computational complexity of constructor term rewriting systems where every function and constructor symbol is unary or nullary. Surprisingly, adding simple and natural constraints to rule formation yields classes of systems that accept exactly the four classes of languages in the Chomsky hierarchy
Term Rewriting Characterisation of LOGSPACE for Finite and Infinite Data
We show that LOGSPACE is characterised by finite orthogonal tail-recursive cons-free constructor term rewriting systems, contributing to a line of research initiated by Neil Jones. We describe a LOGSPACE algorithm which computes constructor normal forms. This algorithm is used in the proof of our main result: that simple stream term rewriting systems characterise LOGSPACE-computable stream functions as defined by Ramyaa and Leivant. This result concerns characterising logarithmic-space computation on infinite streams by means of infinitary rewriting