257 research outputs found
The exp-log normal form of types
Lambda calculi with algebraic data types lie at the core of functional
programming languages and proof assistants, but conceal at least two
fundamental theoretical problems already in the presence of the simplest
non-trivial data type, the sum type. First, we do not know of an explicit and
implemented algorithm for deciding the beta-eta-equality of terms---and this in
spite of the first decidability results proven two decades ago. Second, it is
not clear how to decide when two types are essentially the same, i.e.
isomorphic, in spite of the meta-theoretic results on decidability of the
isomorphism.
In this paper, we present the exp-log normal form of types---derived from the
representation of exponential polynomials via the unary exponential and
logarithmic functions---that any type built from arrows, products, and sums,
can be isomorphically mapped to. The type normal form can be used as a simple
heuristic for deciding type isomorphism, thanks to the fact that it is a
systematic application of the high-school identities.
We then show that the type normal form allows to reduce the standard beta-eta
equational theory of the lambda calculus to a specialized version of itself,
while preserving the completeness of equality on terms. We end by describing an
alternative representation of normal terms of the lambda calculus with sums,
together with a Coq-implemented converter into/from our new term calculus. The
difference with the only other previously implemented heuristic for deciding
interesting instances of eta-equality by Balat, Di Cosmo, and Fiore, is that we
exploit the type information of terms substantially and this often allows us to
obtain a canonical representation of terms without performing sophisticated
term analyses
Strongly Normalizing Higher-Order Relational Queries
Language-integrated query is a powerful programming construct allowing database queries and ordinary program code to interoperate seamlessly and safely. Language-integrated query techniques rely on classical results about monadic comprehension calculi, including the conservativity theorem for nested relational calculus. Conservativity implies that query expressions can freely use nesting and unnesting, yet as long as the query result type is a flat relation, these capabilities do not lead to an increase in expressiveness over flat relational queries. Wong showed how such queries can be translated to SQL via a constructive rewriting algorithm, and Cooper and others advocated higher-order nested relational calculi as a basis for language-integrated queries in functional languages such as Links and F#. However there is no published proof of the central strong normalization property for higher-order nested relational queries: a previous proof attempt does not deal correctly with rewrite rules that duplicate subterms. This paper fills the gap in the literature, explaining the difficulty with a previous proof attempt, and showing how to extend the ??-lifting approach of Lindley and Stark to accommodate duplicating rewrites. We also sketch how to extend the proof to a recently-introduced calculus for heterogeneous queries mixing set and multiset semantics
Normalisation by Evaluation in the Compilation of Typed Functional Programming Languages
This thesis presents a critical analysis of normalisation by evaluation as a technique for
speeding up compilation of typed functional programming languages. Our investigation
focuses on the SML.NET compiler and its typed intermediate language MIL. We
implement and measure the performance of normalisation by evaluation for MIL across
a range of benchmarks. Taking a different approach, we also implement and measure
the performance of a graph-based shrinking reductions algorithm for SML.NET.
MIL is based on Moggiâs computational metalanguage. As a stepping stone to
normalisation by evaluation, we investigate strong normalisation of the computational
metalanguage by introducing an extension of Girard-Tait reducibility. Inspired by previous
work on local state and parametric polymorphism, we define reducibility for
continuations and more generally reducibility for frame stacks. First we prove strong
normalistion for the computational metalanguage. Then we extend that proof to include
features of MIL such as sums and exceptions.
Taking an incremental approach, we construct a collection of increasingly sophisticated
normalisation by evaluation algorithms, culminating in a range of normalisation
algorithms for MIL. Congruence rules and alpha-rules are captured by a compositional
parameterised semantics. Defunctionalisation is used to eliminate eta-rules. Normalisation
by evaluation for the computational metalanguage is introduced using a monadic
semantics. Variants in which the monadic effects are made explicit, using either state
or control operators, are also considered.
Previous implementations of normalisation by evaluation with sums have relied
on continuation-passing-syle or control operators. We present a new algorithm which
instead uses a single reference cell and a zipper structure. This suggests a possible
alternative way of implementing Filinskiâs monadic reflection operations.
In order to obtain benchmark results without having to take into account all of
the features of MIL, we implement two different techniques for eliding language constructs.
The first is not semantics-preserving, but is effective for assessing the efficiency
of normalisation by evaluation algorithms. The second is semantics-preserving,
but less flexible. In common with many intermediate languages, but unlike the computational
metalanguage, MIL requires all non-atomic values to be named. We use either
control operators or state to ensure each non-atomic value is named.
We assess our normalisation by evaluation algorithms by comparing them with a
spectrum of progressively more optimised, rewriting-based normalisation algorithms.
The SML.NET front-end is used to generate MIL code from ML programs, including
the SML.NET compiler itself. Each algorithm is then applied to the generated MIL
code. Normalisation by evaluation always performs faster than the most naıve algorithmsâ
often by orders of magnitude. Some of the algorithms are slightly faster than
normalisation by evaluation. Closer inspection reveals that these algorithms are in fact
defunctionalised versions of normalisation by evaluation algorithms.
Our normalisation by evaluation algorithms perform unrestricted inlining of functions.
Unrestricted inlining can lead to a super-exponential blow-up in the size of
target code with respect to the source. Furthermore, the worst-case complexity of
compilation with unrestricted inlining is non-elementary in the size of the source code.
SML.NET alleviates both problems by using a restricted form of normalisation based
on Appel and Jimâs shrinking reductions. The original algorithm is quadratic in the
worst case. Using a graph-based representation for terms we implement a compositional
linear algorithm. This speeds up the time taken to perform shrinking reductions
by up to a factor of fourteen, which leads to an improvement of up to forty percent in
total compile time
Formal Compiler Implementation in a Logical Framework
The task of designing and implementing a compiler can be a difficult and error-prone process. In this paper, we present a new approach based on the use of higher-order abstract syntax and term rewriting in a logical framework. All program transformations, from parsing to code generation, are cleanly isolated and specified as term rewrites. This has several advantages. The correctness of the compiler depends solely on a small set of rewrite rules that are written in the language of formal mathematics. In addition, the logical framework guarantees the preservation of scoping, and it automates many frequently-occurring tasks including substitution and rewriting strategies. As we show, compiler development in a logical framework can be easier than in a general-purpose language like ML, in part because of automation, and also because the framework provides extensive support for examination, validation, and debugging of the compiler transformations. The paper is organized around a case study, using the MetaPRL logical framework to compile an ML-like language to Intel x86 assembly. We also present a scoped formalization of x86 assembly in which all registers are immutable
Executable component-based semantics
The potential benefits of formal semantics are well known. However, a substantial amount of work is required to produce a complete and accurate formal semantics for a major language; and when the language evolves, large-scale revision of the semantics may be needed to reflect the changes. The investment of effort needed to produce an initial definition, and subsequently to revise it, has discouraged language developers from using formal semantics. Consequently, many major programming languages (and most domain-specific languages) do not yet have formal semantic definitions.To improve the practicality of formal semantic definitions, the PLanCompS project has developed a component-based approach. In this approach, the semantics of a language is defined by translating its constructs (compositionally) to combinations of so-called fundamental constructs, or âfunconsâ. Each funcon is defined using a modular variant of Structural Operational Semantics, and forms a language-independent component that can be reused in definitions of different languages. A substantial library of funcons has been developed and tested in several case studies. Crucially, the definition of each funcon is fixed, and does not need changing when new funcons are added to the library.For specifying component-based semantics, we have designed and implemented a meta-language called CBS. It includes specification of abstract syntax, of its translation to funcons, and of the funcons themselves. Development of CBS specifications is supported by an integrated development environment. The accuracy of a language definition can be tested by executing the specified translation on programs written in the defined language, and then executing the resulting funcon terms using an interpreter generated from the CBS definitions of the funcons. This paper gives an introduction to CBS, illustrates its use, and presents the various tools involved in our implementation of CBS
Decidability for Non-Standard Conversions in Typed Lambda-Calculi
This thesis studies the decidability of conversions in typed lambda-calculi, along with the algorithms allowing for this decidability. Our study takes in consideration conversions going beyond the traditional beta, eta, or permutative conversions (also called commutative conversions). To decide these conversions, two classes of algorithms compete, the algorithms based on rewriting, here the goal is to decompose and orient the conversion so as to obtain a convergent system, these algorithms then boil down to rewrite the terms until they reach an irreducible forms; and the "reduction free" algorithms where the conversion is decided recursively by a detour via a meta-language. Throughout this thesis, we strive to explain the latter thanks to the former
A formally verified compiler back-end
This article describes the development and formal verification (proof of
semantic preservation) of a compiler back-end from Cminor (a simple imperative
intermediate language) to PowerPC assembly code, using the Coq proof assistant
both for programming the compiler and for proving its correctness. Such a
verified compiler is useful in the context of formal methods applied to the
certification of critical software: the verification of the compiler guarantees
that the safety properties proved on the source code hold for the executable
compiled code as well
Strongly-Normalizing Higher-Order Relational Queries
Language-integrated query is a powerful programming construct allowing
database queries and ordinary program code to interoperate seamlessly and
safely. Language-integrated query techniques rely on classical results about
the nested relational calculus, stating that its queries can be algorithmically
translated to SQL, as long as their result type is a flat relation. Cooper and
others advocated higher-order nested relational calculi as a basis for
language-integrated queries in functional languages such as Links and F#.
However, the translation of higher-order relational queries to SQL relies on a
rewrite system for which no strong normalization proof has been published: a
previous proof attempt does not deal correctly with rewrite rules that
duplicate subterms. This paper fills the gap in the literature, explaining the
difficulty with a previous proof attempt, and showing how to extend the
-lifting approach of Lindley and Stark to accommodate duplicating
rewrites. We also show how to extend the proof to a recently-introduced
calculus for heterogeneous queries mixing set and multiset semantics
- âŠ