Curry-Howard Research Articles

Imperative programs as proofs via game semantics

Game semantics extends the Curry–Howard isomorphism to a three-way correspondence: proofs, programs, strategies. But the universe of strategies goes beyond intuitionistic logics and lambda calculus, to capture stateful programs. In this paper we describe a logical counterpart to this extension, in which proofs denote such strategies. The system is expressive: it contains all of the connectives of Intuitionistic Linear Logic, and first-order quantification. Use of Lairdʼs sequoid operator allows proofs with imperative behaviour to be expressed. Thus, we can embed first-order Intuitionistic Linear Logic into this system, Polarized Linear Logic, and an imperative total programming language.The proof system has a tight connection with a simple game model, where games are forests of plays. Formulas are modelled as games, and proofs as history-sensitive winning strategies. We provide a strong full completeness result with respect to this model: each finitary strategy is the denotation of a unique analytic (cut-free) proof. Infinite strategies correspond to analytic proofs that are infinitely deep. Thus, we can normalise proofs, via the semantics.

The untyped stack calculus and Bohm's theorem

The stack calculus is a functional language in which is in a Curry-Howard correspondence with classical logic. It enjoys confluence but, as well as Parigot's lambda-mu, does not admit the Bohm Theorem, typical of the lambda-calculus. We present a simple extension of stack calculus which is for the stack calculus what Saurin's Lambda-mu is for lambda-mu.

The stack calculus

We introduce a functional calculus with simple syntax and operational semantics in which the calculi introduced so far in the Curry-Howard correspondence for Classical Logic can be faithfully encoded. Our calculus enjoys confluence without any restriction. Its type system enforces strong normalization of expressions and it is a sound and complete system for full implicational Classical Logic. We give a very simple denotational semantics which allows easy calculations of the interpretation of expressions.

Towards a Common Categorical Semantics for Linear-Time Temporal Logic and Functional Reactive Programming

Linear-time temporal logic (LTL) and functional reactive programming (FRP) are related via a Curry–Howard correspondence. Based on this observation, we develop a common categorical semantics for a subset of LTL and its corresponding flavor of FRP. We devise a class of categorical models, called fan categories, that explicitly reflect the notion of time-dependent trueness of temporal propositions and a corresponding notion of time-dependent type inhabitance in FRP. Afterwards, we define the more abstract concept of temporal category by extending categorical models of intuitionistic S4. We show that fan categories are a special form of temporal categories.

Minimal from classical proofs

Let A be a formula without implications, and Γ consist of formulas containing disjunction and falsity only negatively and implication only positively. Orevkov (1968) and Nadathur (2000) proved that classical derivability of A from Γ implies intuitionistic derivability, by a transformation of derivations in sequent calculi. We give a new proof of this result (for minimal rather than intuitionistic logic), where the input data are natural deduction proofs in long normal form (given as proof terms via the Curry–Howard correspondence) involving stability axioms for relations; the proof gives a quadratic algorithm to remove the stability axioms. This can be of interest for computational uses of classical proofs.

Böhm theorem and Böhm trees for the [formula omitted]-calculus

Parigot’s λμ-calculus (Parigot, 1992 [1]) is now a standard reference about the computational content of classical logic as well as for the formal study of control operators in functional languages. In addition to the fine-grained Curry–Howard correspondence between minimal classical deductions and simply typed λμ-terms and to the ability to encode many usual control operators such as call/cc in the λμ-calculus (in its historical call-by-name presentation or in call-by-value versions), the success of theλμ-calculus comes from its simplicity, its good meta-theoretical properties both as a typed and an untyped calculus (confluence, strong normalization, etc.) as well as the fact that it naturally extends Church’s λ-calculus. Though, in 2001, David and Py proved [2] that Böhm’s theorem, which is a fundamental result of the untyped λ-calculus, cannot be lifted to Parigot’s calculus.In the present article, we exhibit a natural extension to Parigot’s calculus, theΛμ-calculus, in which Böhm’s property, also known as separation property, can be stated and proved. This is made possible by a careful and detailed analysis of David and Py’s proof of non-separability and of the characteristics of the λμ-calculus which break the property: we identify that the crucial point lies in the design of Parigot’s λμ-calculus with a two-level syntax. In addition, we establish a standardization theorem for the extended calculus, deduce a characterization of solvability, describe Λμ-Böhm trees and connect the calculus with stream computing and delimited control.

Completeness and Soundness Results for 𝒳 with Intersection and Union Types

With the eye on defining a type-based semantics, this paper defines intersection and union type assignment for the sequent calculus X, a substitution-free language that enjoys the Curry-Howard correspondence with respect to the implicative fragment of Gentzen's sequent calculus for classical logic. We investigate the minimal requirements for such a system to be complete i.e. closed under redex expansion, and show that the non-logical nature of both intersection and union types disturbs the soundness i.e. closed uder reduction properties. This implies that this notion of intersection-union type assignment needs to be restricted to satisfy soundness as well, making it unsuitable to define a semantics. We will look at two confluent notions of reduction, called Call-by-Name and Call-by-Value, and prove soundness results for those.

Constructive linear-time temporal logic: Proof systems and Kripke semantics

In this paper we study a version of constructive linear-time temporal logic (LTL) with the “next” temporal operator. The logic is originally due to Davies, who has shown that the proof system of the logic corresponds to a type system for binding-time analysis via the Curry–Howard isomorphism. However, he did not investigate the logic itself in detail; he has proved only that the logic augmented with negation and classical reasoning is equivalent to (the “next” fragment of) the standard formulation of classical linear-time temporal logic. We give natural deduction, sequent calculus and Hilbert-style proof systems for constructive LTL with conjunction, disjunction and falsehood, and show that the sequent calculus enjoys cut elimination. Moreover, we also consider Kripke semantics and prove soundness and completeness. One distinguishing feature of this logic is that distributivity of the “next” operator over disjunction “ ◯ ( A ∨ B ) ⊃ ◯ A ∨ ◯ B ” is rejected in view of a type-theoretic interpretation.

A new graphical calculus of proofs

We offer a simple graphical representation for proofs of intuitionistic logic, which is inspired by proof nets and interaction nets (two formalisms originating in linear logic). This graphical calculus of proofs inherits good features from each, but is not constrained by them. By the Curry-Howard isomorphism, the representation applies equally to the lambda calculus, offering an alternative diagrammatic representation of functional computations.

Scalar System F for Linear-Algebraic λ-Calculus: Towards a Quantum Physical Logic

The Linear-Algebraic λ-Calculus [Arrighi, P. and G. Dowek, Linear-algebraic λ-calculus: higher-order, encodings and confluence, Lecture Notes in Computer Science (RTA'08) 5117 (2008), pp. 17–31] extends the λ-calculus with the possibility of making arbitrary linear combinations of terms α.t+β.u. Since one can express fixed points over sums in this calculus, one has a notion of infinities arising, and hence indefinite forms. As a consequence, in order to guarantee the confluence, t−t does not always reduce to 0 – only if t is closed normal. In this paper we provide a System F like type system for the Linear-Algebraic λ-Calculus, which guarantees normalisation and hence no need for such restrictions, t−t always reduces to 0. Moreover this type system keeps track of 'the amount of a type'. As such it can be seen as probabilistic type system, guaranteeing that terms define correct probabilistic functions. It can also be seen as a step along the quest toward a quantum physical logic through the Curry-Howard isomorphism [Sørensen, M. H. and P. Urzyczyn, “Lectures on the Curry-Howard Isomorphism, Volume 149 (Studies in Logic and the Foundations of Mathematics),” Elsevier Science Inc., New York, NY, USA, 2006].

Superdeduction in Lambda-Bar-Mu-Mu-Tilde

Superdeduction is a method specially designed to ease the use of first-order theories in predicate logic. The theory is used to enrich the deduction system with new deduction rules in a systematic, correct and complete way. A proof-term language and a cut-elimination reduction already exist for superdeduction, both based on Christian Urban's work on classical sequent calculus. However the computational content of Christian Urban's calculus is not directly related to the (lambda-calculus based) Curry-Howard correspondence. In contrast the Lambda bar mu mu tilde calculus is a lambda-calculus for classical sequent calculus. This short paper is a first step towards a further exploration of the computational content of superdeduction proofs, for we extend the Lambda bar mu mu tilde calculus in order to obtain a proofterm langage together with a cut-elimination reduction for superdeduction. We also prove strong normalisation for this extension of the Lambda bar mu mu tilde calculus.

A Logical Foundation for Environment Classifiers

Taha and Nielsen have developed a multi-stage calculus {\lambda}{\alpha} with a sound type system using the notion of environment classifiers. They are special identifiers, with which code fragments and variable declarations are annotated, and their scoping mechanism is used to ensure statically that certain code fragments are closed and safely runnable. In this paper, we investigate the Curry-Howard isomorphism for environment classifiers by developing a typed {\lambda}-calculus {\lambda}|>. It corresponds to multi-modal logic that allows quantification by transition variables---a counterpart of classifiers---which range over (possibly empty) sequences of labeled transitions between possible worlds. This interpretation will reduce the "run" construct---which has a special typing rule in {\lambda}{\alpha}---and embedding of closed code into other code fragments of different stages---which would be only realized by the cross-stage persistence operator in {\lambda}{\alpha}---to merely a special case of classifier application. {\lambda}|> enjoys not only basic properties including subject reduction, confluence, and strong normalization but also an important property as a multi-stage calculus: time-ordered normalization of full reduction. Then, we develop a big-step evaluation semantics for an ML-like language based on {\lambda}|> with its type system and prove that the evaluation of a well-typed {\lambda}|> program is properly staged. We also identify a fragment of the language, where erasure evaluation is possible. Finally, we show that the proof system augmented with a classical axiom is sound and complete with respect to a Kripke semantics of the logic.

A Monadic Formalization of ML5

ML5 is a programming language for spatially distributed computing, based on a Curry-Howard correspondence with the modal logic S5. Despite being designed by a correspondence with S5 modal logic, the ML5 programming language differs from the logic in several ways. In this paper, we explain these discrepancies between ML5 and S5 by translating ML5 into a slightly different logic: intuitionistic S5 extended with a lax modality that encapsulates effectful computations in a monad. This translation both explains the existing ML5 design and suggests some simplifications and generalizations. We have formalized our translation within the Agda proof assistant. Rather than formalizing lax S5 as a proof theory, we \emph{embed} it as a universe within the the dependently typed host language, with the universe elimination given by implementing the modal logic's Kripke semantics. This representation technique saves us the work of defining a proof theory for the logic and proving it correct, and additionally allows us to inherit the equational theory of the meta-language, which can be exploited in proving that the semantics validates the operational semantics of ML5.

Soundness and principal contexts for a shallow polymorphic type system based on classical logic

In this paper we investigate how to adapt the well-known notion of ML-style polymorphism (shallow polymorphism) to a term calculus based on a Curry-Howard correspondence with classical sequent calculus, namely, theX i -calculus. We show that the intuitive approach is unsound, and pinpoint the precise nature of the problem. We define a suitably refined type system, and prove its sou ndness. We then define a notion of principal contextsfor the type system, and provide an algorithm to compute these, which is proved to be sound and complete with respect to the type system. In the process, we formalise and prove correctness of generic unification, which generalises Robinson’s unification to shallow-poly morphic types.

Parametricity, type equality, and higher-order polymorphism

AbstractPropositions that express type equality are a frequent ingredient of modern functional programming – they can encode generic functions, dynamic types, and GADTs. Via the Curry–Howard correspondence, these propositions are ordinarytypesinhabited by proofterms, computed using runtime type representations. In this paper we show that two examples of type equality propositions actually do reflect type equality; they are only inhabited when their arguments are equal and their proofs are unique (up to equivalence.) We show this result in the context of a strongly normalizing language with higher-order polymorphism and primitive recursion over runtime-type representations by proving Reynolds's abstraction theorem. We then use this theorem to derive “free” theorems about equality types.

Towards an embedding of Graph Transformation in Intuitionistic Linear Logic

Linear logics have been shown to be able to embed both rewriting-based approaches and process calculi in a single, declarative framework. In this paper we are exploring the embedding of double-pushout graph transformations into quantified linear logic, leading to a Curry-Howard style isomorphism between graphs and transformations on one hand, formulas and proof terms on the other. With linear implication representing rules and reachability of graphs, and the tensor modelling parallel composition of graphs and transformations, we obtain a language able to encode graph transformation systems and their computations as well as reason about their properties.

Curry-Howard for incomplete first-order logic derivations using one-and-a-half level terms

The Curry-Howard correspondence connects derivations in natural deduction with the lambda-calculus. Predicates are types, derivations are terms. This supports reasoning from assumptions to conclusions, but we may want to reason backwards; from the desired conclusion towards the assumptions. At intermediate stages we may have a partial derivation, with holes. This is natural in informal practice but it can be difficult to formalise. The informal act of filling holes in a partial derivation suggests a capturing substitution, since holes may occur in the scope of quantifier introduction rules. As other authors have observed, this is not immediately supported by the lambda-calculus. Also, universal quantification requires a ‘fresh name’ and it is not immediately obvious what formal meaning to assign to this notion if derivations are incomplete. Further issues arise with proof-normalisation; this corresponds with lambda-calculus reduction, which can require alpha-conversion to avoid capture when beta-reducing, and it is not immediately clear how to alpha-convert a name in an incomplete derivation. We apply a one-and-a-half level technique based on nominal terms to construct a Curry-Howard correspondence for first-order logic. This features two levels of variable, but with no lambda-abstraction at the second level. Predicates are types, derivations are terms, proof-normalisation is reduction — and the two levels of variable are, respectively, the assumptions and the holes of an incomplete derivation. We give notions of proof-term, typing, alpha-conversion and beta-reduction for our syntax. We prove confluence, we exhibit several admissible rules including a proof that instantiation of level two variables is type-safe — this corresponds with the act of filling holes in an incomplete derivation, and can be viewed as a form of Cut-rule — and we explore the connection with traditional Curry-Howard in the case that the derivation is in fact complete. Our techniques are not specifically tailored to first-order logic and the same ideas should be applicable without any essential new difficulties to similar logical systems.

Modeling abstract types in modules with open existential types

We propose F-zip, a calculus of open existential types that is an extension of System F obtained by decomposing the introduction and elimination of existential types into more atomic constructs. Open existential types model modular type abstraction as done in module systems. The static semantics of F-zip adapts standard techniques to deal with linearity of typing contexts, its dynamic semantics is a small-step reduction semantics that performs extrusion of type abstraction as needed during reduction, and the two are related by subject reduction and progress lemmas. Applying the Curry-Howard isomorphism, F-zip can be also read back as a logic with the same expressive power as second-order logic but with more modular ways of assembling partial proofs. We also extend the core calculus to handle the double vision problem as well as type-level and term-level recursion. The resulting language turns out to be a new formalization of (a minor variant of) Dreyer's internal language for recursive and mixin modules.

Focusing on pattern matching

In this paper, we show how pattern matching can be seen to arise from a proof term assignment for the focused sequent calculus. This use of the Curry-Howard correspondence allows us to give a novel coverage checking algorithm, and makes it possible to give a rigorous correctness proof for the classical pattern compilation strategy of building decision trees via matrices of patterns.

Le concept d’opérateur en linguistique

Linguists do not always use the term “ operator” clearly. Still, applying an operator to an operand is a basic operation in some applicative formalisms (λ-calculus, combinatory logics, functional programming) used by linguists. An operator is associated to syncategorematic linguistic expressions. Church’s functional types are a suitable formalization of different types of operators in Categorial Grammars. Since linguistic units are viewed as operators, they can be composed by means of the combinators of Curry’s Combinatory Logic. A formal link between application and implication in propositional calculus explains the relevance of the Curry-Howard correspondence between functional types and the implication in propositional calculus ; this correspondence is evaluated in the field of linguistics.