294 research outputs found
Linear Dependent Types in a Call-by-Value Scenario (Long Version)
Linear dependent types allow to precisely capture both the extensional
behaviour and the time complexity of lambda terms, when the latter are
evaluated by Krivine's abstract machine. In this work, we show that the same
paradigm can be applied to call-by-value evaluation. A system of linear
dependent types for Plotkin's PCF is introduced, called dlPCFV, whose types
reflect the complexity of evaluating terms in the so-called CEK machine. dlPCFV
is proved to be sound, but also relatively complete: every true statement about
the extensional and intentional behaviour of terms can be derived, provided all
true index term inequalities can be used as assumptions.Comment: 22 page
Circuit Width Estimation via Effect Typing and Linear Dependency (Long Version)
Circuit description languages are a class of quantum programming languages in
which programs are classical and produce a description of a quantum
computation, in the form of a quantum circuit. Since these programs can
leverage all the expressive power of high-level classical languages, circuit
description languages have been successfully used to describe complex and
practical quantum algorithms, whose circuits, however, may involve many more
qubits and gate applications than current quantum architectures can actually
muster. In this paper, we present Proto-Quipper-R, a circuit description
language endowed with a linear dependent type-and-effect system capable of
deriving parametric upper bounds on the width of the circuits produced by a
program. We prove both the standard type safety results and that the resulting
resource analysis is correct with respect to a big-step operational semantics.
We also show that our approach is expressive enough to verify realistic quantum
algorithms.Comment: 21 pages (excluding references), 21 figure
Compilation of extended recursion in call-by-value functional languages
This paper formalizes and proves correct a compilation scheme for
mutually-recursive definitions in call-by-value functional languages. This
scheme supports a wider range of recursive definitions than previous methods.
We formalize our technique as a translation scheme to a lambda-calculus
featuring in-place update of memory blocks, and prove the translation to be
correct.Comment: 62 pages, uses pi
On the Relative Usefulness of Fireballs
In CSL-LICS 2014, Accattoli and Dal Lago showed that there is an
implementation of the ordinary (i.e. strong, pure, call-by-name)
-calculus into models like RAM machines which is polynomial in the
number of -steps, answering a long-standing question. The key ingredient
was the use of a calculus with useful sharing, a new notion whose complexity
was shown to be polynomial, but whose implementation was not explored. This
paper, meant to be complementary, studies useful sharing in a call-by-value
scenario and from a practical point of view. We introduce the Fireball
Calculus, a natural extension of call-by-value to open terms for which the
problem is as hard as for the ordinary lambda-calculus. We present three
results. First, we adapt the solution of Accattoli and Dal Lago, improving the
meta-theory of useful sharing. Then, we refine the picture by introducing the
GLAMoUr, a simple abstract machine implementing the Fireball Calculus extended
with useful sharing. Its key feature is that usefulness of a step is
tested---surprisingly---in constant time. Third, we provide a further
optimization that leads to an implementation having only a linear overhead with
respect to the number of -steps.Comment: Technical report for the LICS 2015 submission with the same titl
In Search of Effectful Dependent Types
Real world programming languages crucially depend on the availability of
computational effects to achieve programming convenience and expressive power
as well as program efficiency. Logical frameworks rely on predicates, or
dependent types, to express detailed logical properties about entities.
According to the Curry-Howard correspondence, programming languages and logical
frameworks should be very closely related. However, a language that has both
good support for real programming and serious proving is still missing from the
programming languages zoo. We believe this is due to a fundamental lack of
understanding of how dependent types should interact with computational
effects. In this thesis, we make a contribution towards such an understanding,
with a focus on semantic methods.Comment: PhD thesis, Version submitted to Exam School
- …