13 research outputs found
Memoization for Unary Logic Programming: Characterizing PTIME
We give a characterization of deterministic polynomial time computation based
on an algebraic structure called the resolution semiring, whose elements can be
understood as logic programs or sets of rewriting rules over first-order terms.
More precisely, we study the restriction of this framework to terms (and logic
programs, rewriting rules) using only unary symbols. We prove it is complete
for polynomial time computation, using an encoding of pushdown automata. We
then introduce an algebraic counterpart of the memoization technique in order
to show its PTIME soundness. We finally relate our approach and complexity
results to complexity of logic programming. As an application of our
techniques, we show a PTIME-completeness result for a class of logic
programming queries which use only unary function symbols.Comment: Soumis {\`a} LICS 201
Interaction Automata and the ia2d Interpreter
We introduce interaction automata as a topological model of
computation and present the conceptual plane interpreter ia2d.
Interaction automata form a refinement of both interaction nets and
cellular automata models that combine data deployment, memory
management and structured computation mechanisms. Their local
structure is inspired from pointer machines and allows an asynchronous
spatial distribution of the computation. Our tool can be considered
as a proof-of-concept piece of abstract hardware on which functional
programs can be run in parallel
Polynomial Path Orders
This paper is concerned with the complexity analysis of constructor term
rewrite systems and its ramification in implicit computational complexity. We
introduce a path order with multiset status, the polynomial path order POP*,
that is applicable in two related, but distinct contexts. On the one hand POP*
induces polynomial innermost runtime complexity and hence may serve as a
syntactic, and fully automatable, method to analyse the innermost runtime
complexity of term rewrite systems. On the other hand POP* provides an
order-theoretic characterisation of the polytime computable functions: the
polytime computable functions are exactly the functions computable by an
orthogonal constructor TRS compatible with POP*.Comment: LMCS version. This article supersedes arXiv:1209.379
The Power of Non-Determinism in Higher-Order Implicit Complexity
We investigate the power of non-determinism in purely functional programming
languages with higher-order types. Specifically, we consider cons-free programs
of varying data orders, equipped with explicit non-deterministic choice.
Cons-freeness roughly means that data constructors cannot occur in function
bodies and all manipulation of storage space thus has to happen indirectly
using the call stack.
While cons-free programs have previously been used by several authors to
characterise complexity classes, the work on non-deterministic programs has
almost exclusively considered programs of data order 0. Previous work has shown
that adding explicit non-determinism to cons-free programs taking data of order
0 does not increase expressivity; we prove that this - dramatically - is not
the case for higher data orders: adding non-determinism to programs with data
order at least 1 allows for a characterisation of the entire class of
elementary-time decidable sets.
Finally we show how, even with non-deterministic choice, the original
hierarchy of characterisations is restored by imposing different restrictions.Comment: pre-edition version of a paper accepted for publication at ESOP'1
Reasoning about the garden of forking paths
Lazy evaluation is a powerful tool for functional programmers. It enables the
concise expression of on-demand computation and a form of compositionality not
available under other evaluation strategies. However, the stateful nature of
lazy evaluation makes it hard to analyze a program's computational cost, either
informally or formally. In this work, we present a novel and simple framework
for formally reasoning about lazy computation costs based on a recent model of
lazy evaluation: clairvoyant call-by-value. The key feature of our framework is
its simplicity, as expressed by our definition of the clairvoyance monad. This
monad is both simple to define (around 20 lines of Coq) and simple to reason
about. We show that this monad can be effectively used to mechanically reason
about the computational cost of lazy functional programs written in Coq.Comment: 28 pages, accepted by ICFP'2
Polynomial Time and Dependent Types
We combine dependent types with linear type systems that soundly and
completely capture polynomial time computation. We explore two systems for
capturing polynomial time: one system that disallows construction of iterable
data, and one, based on the LFPL system of Martin Hofmann, that controls
construction via a payment method. Both of these are extended to full dependent
types via Quantitative Type Theory, allowing for arbitrary computation in types
alongside guaranteed polynomial time computation in terms. We prove the
soundness of the systems using a realisability technique due to Dal Lago and
Hofmann.
Our long-term goal is to combine the extensional reasoning of type theory
with intensional reasoning about the resources intrinsically consumed by
programs. This paper is a step along this path, which we hope will lead both to
practical systems for reasoning about programs' resource usage, and to
theoretical use as a form of synthetic computational complexity theory
On the Resolution Semiring
In this thesis, we study a semiring structure with a product based on theresolution rule of logic programming. This mathematical object was introducedinitially in the setting of the geometry of interaction program in order to modelthe cut-elimination procedure of linear logic. It provides us with an algebraicand abstract setting, while being presented in a syntactic and concrete way, inwhich a theoretical study of computation can be carried on.We will review first the interactive interpretation of proof theory withinthis semiring via the categorical axiomatization of the geometry of interactionapproach. This interpretation establishes a way to translate functional programsinto a very simple form of logic programs.Secondly, complexity theory problematics will be considered: while thenilpotency problem in the semiring we study is undecidable in general, it willappear that certain restrictions allow for characterizations of (deterministicand non-deterministic) logarithmic space and (deterministic) polynomial timecomputation
A programming language characterizing quantum polynomial time
We introduce a first-order quantum programming language, named FOQ, whose terminating programs are reversible. We restrict FOQ to a strict and tractable subset, named PFOQ, of terminating programs with bounded width, that provides a first programming language-based characterization of the quantum complexity class FBQP. Finally, we present a tractable semantics-preserving algorithm compiling a PFOQ program to a quantum circuit of size polynomial in the number of input qubits
Probabilistic Termination by Monadic Affine Sized Typing
International audienceWe introduce a system of monadic affine sized types, which substantially generalise usual sized types, and allows this way to capture probabilistic higher-order programs which terminate almost surely. Going beyond plain, strong normalisation without losing soundness turns out to be a hard task, which cannot be accomplished without a richer, quantitative notion of types, but also without imposing some affinity constraints. The proposed type system is powerful enough to type classic examples of probabilistically terminating programs such as random walks. The way typable programs are proved to be almost surely terminating is based on reducibility, but requires a substantial adaptation of the technique
Polynomial time and dependent types
We combine dependent types with linear type systems that soundly and completely capture polynomial time computation. We explore two systems for capturing polynomial time: one system that disallows construction of iterable data, and one, based on the LFPL system of Martin Hofmann, that controls construction via a payment method. Both of these are extended to full dependent types via Quantitative Type Theory, allowing for arbitrary computation in types alongside guaranteed polynomial time computation in terms. We prove the soundness of the systems using a realisability technique due to Dal Lago and Hofmann. Our long-term goal is to combine the extensional reasoning of type theory with intensional reasoning about the resources intrinsically consumed by programs. This paper is a step along this path, which we hope will lead both to practical systems for reasoning about programs’ resource usage, and to theoretical use as a form of synthetic computational complexity theory