1,101 research outputs found
Higher-Order Termination: from Kruskal to Computability
Termination is a major question in both logic and computer science. In logic,
termination is at the heart of proof theory where it is usually called strong
normalization (of cut elimination). In computer science, termination has always
been an important issue for showing programs correct. In the early days of
logic, strong normalization was usually shown by assigning ordinals to
expressions in such a way that eliminating a cut would yield an expression with
a smaller ordinal. In the early days of verification, computer scientists used
similar ideas, interpreting the arguments of a program call by a natural
number, such as their size. Showing the size of the arguments to decrease for
each recursive call gives a termination proof of the program, which is however
rather weak since it can only yield quite small ordinals. In the sixties, Tait
invented a new method for showing cut elimination of natural deduction, based
on a predicate over the set of terms, such that the membership of an expression
to the predicate implied the strong normalization property for that expression.
The predicate being defined by induction on types, or even as a fixpoint, this
method could yield much larger ordinals. Later generalized by Girard under the
name of reducibility or computability candidates, it showed very effective in
proving the strong normalization property of typed lambda-calculi..
Functionality, Polymorphism, and Concurrency: A Mathematical Investigation of Programming Paradigms
The search for mathematical models of computational phenomena often leads to problems that are of independent mathematical interest. Selected problems of this kind are investigated in this thesis. First, we study models of the untyped lambda calculus. Although many familiar models are constructed by order-theoretic methods, it is also known that there are some models of the lambda calculus that cannot be non-trivially ordered. We show that the standard open and closed term algebras are unorderable. We characterize the absolutely unorderable T-algebras in any algebraic variety T. Here an algebra is called absolutely unorderable if it cannot be embedded in an orderable algebra. We then introduce a notion of finite models for the lambda calculus, contrasting the known fact that models of the lambda calculus, in the traditional sense, are always non-recursive. Our finite models are based on Plotkinâs syntactical models of reduction. We give a method for constructing such models, and some examples that show how finite models can yield useful information about terms. Next, we study models of typed lambda calculi. Models of the polymorphic lambda calculus can be divided into environment-style models, such as Bruce and Meyerâs non-strict set-theoretic models, and categorical models, such as Seelyâs interpretation in PL-categories. Reynolds has shown that there are no set-theoretic strict models. Following a different approach, we investigate a notion of non-strict categorical models. These provide a uniform framework in which one can describe various classes of non-strict models, including set-theoretic models with or without empty types, and Kripke-style models. We show that completeness theorems correspond to categorical representation theorems, and we reprove a completeness result by Meyer et al. on set-theoretic models of the simply-typed lambda calculus with possibly empty types. Finally, we study properties of asynchronous communication in networks of communicating processes. We formalize several notions of asynchrony independently of any particular concurrent process paradigm. A process is asynchronous if its input and/or output is filtered through a communication medium, such as a buffer or a queue, possibly with feedback. We prove that the behavior of asynchronous processes can be equivalently characterized by first-order axioms
On correctness of buffer implementations in a concurrent lambda calculus with futures
Motivated by the question of correctness of a specific implementation of concurrent buffers in the lambda calculus with futures underlying Alice ML, we prove that concurrent buffers and handled futures can correctly encode each other. Correctness means that our encodings preserve and reflect the observations of may- and must-convergence. This also shows correctness wrt. program semantics, since the encodings are adequate translations wrt. contextual semantics. While these translations encode blocking into queuing and waiting, we also provide an adequate encoding of buffers in a calculus without handles, which is more low-level and uses busy-waiting instead of blocking. Furthermore we demonstrate that our correctness concept applies to the whole compilation process from high-level to low-level concurrent languages, by translating the calculus with buffers, handled futures and data constructors into a small core language without those constructs
A new coinductive confluence proof for infinitary lambda calculus
We present a new and formal coinductive proof of confluence and normalisation
of B\"ohm reduction in infinitary lambda calculus. The proof is simpler than
previous proofs of this result. The technique of the proof is new, i.e., it is
not merely a coinductive reformulation of any earlier proofs. We formalised the
proof in the Coq proof assistant.Comment: arXiv admin note: text overlap with arXiv:1501.0435
The computability path ordering
This paper aims at carrying out termination proofs for simply typed
higher-order calculi automatically by using ordering comparisons. To this end,
we introduce the computability path ordering (CPO), a recursive relation on
terms obtained by lifting a precedence on function symbols. A first version,
core CPO, is essentially obtained from the higher-order recursive path ordering
(HORPO) by eliminating type checks from some recursive calls and by
incorporating the treatment of bound variables as in the com-putability
closure. The well-foundedness proof shows that core CPO captures the essence of
computability arguments \'a la Tait and Girard, therefore explaining its name.
We further show that no further type check can be eliminated from its recursive
calls without loosing well-foundedness, but for one for which we found no
counterexample yet. Two extensions of core CPO are then introduced which allow
one to consider: the first, higher-order inductive types; the second, a
precedence in which some function symbols are smaller than application and
abstraction
The Algebraic Intersection Type Unification Problem
The algebraic intersection type unification problem is an important component
in proof search related to several natural decision problems in intersection
type systems. It is unknown and remains open whether the algebraic intersection
type unification problem is decidable. We give the first nontrivial lower bound
for the problem by showing (our main result) that it is exponential time hard.
Furthermore, we show that this holds even under rank 1 solutions (substitutions
whose codomains are restricted to contain rank 1 types). In addition, we
provide a fixed-parameter intractability result for intersection type matching
(one-sided unification), which is known to be NP-complete.
We place the algebraic intersection type unification problem in the context
of unification theory. The equational theory of intersection types can be
presented as an algebraic theory with an ACI (associative, commutative, and
idempotent) operator (intersection type) combined with distributivity
properties with respect to a second operator (function type). Although the
problem is algebraically natural and interesting, it appears to occupy a
hitherto unstudied place in the theory of unification, and our investigation of
the problem suggests that new methods are required to understand the problem.
Thus, for the lower bound proof, we were not able to reduce from known results
in ACI-unification theory and use game-theoretic methods for two-player tiling
games
Proof nets and the call-by-value λ-calculus
International audienceThis paper gives a detailed account of the relationship between (a variant of) the call-by-value lambda calculus and linear logic proof nets. The presentation is carefully tuned in order to realize an isomorphism between the two systems: every single rewriting step on the calculus maps to a single step on proof nets, and viceversa. In this way, we obtain an algebraic reformulation of proof nets. Moreover, we provide a simple correctness criterion for our proof nets, which employ boxes in an unusual way, and identify a subcalculus that is shown to be as expressive as the full calculus
- âŠ