Cocon: Computation in Contextual Type Theory

Journal of Automated Reasoning, 2007

We illustrate a methodology for formalizing and reasoning about Abadi and Cardelli's object-based calculi, in (co)inductive type theory, such as the Calculus of (Co)Inductive Constructions, by taking advantage of Natural Deduction Semantics and coinduction in combination with weak Higher-Order Abstract Syntax and the Theory of Contexts.

2012 27th Annual IEEE Symposium on Logic in Computer Science, 2012

Interactive theorem provers based on higher-order logic (HOL) traditionally follow the definitional approach, reducing high-level specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in HOL4, HOL Light, and Isabelle/ HOL is fundamentally noncompositional, limiting its efficiency and flexibility, and it does not cater for codatatypes.

2008

We show how programming language semantics and definitions of their corresponding type systems can both be written in a single framework amenable to proofs of soundness. The framework is based on full rewriting logic (not to be confused with context reduction or term rewriting), where rules can match anywhere in a term (or configuration).

We discuss di erent ways to represent the syntax of dependent types using Martin-L of type theory as a metalanguage. In particular, we show how to give an intrinsic syntax in which meaningful contexts, types in a context, and terms of a certain type in a context, are generated directly without rst introducing raw terms, types, and contexts. In the rst representation we de ne inductively the normal contexts, types, and terms of the pure theory of dependent types. Simultaneously substitution and lifting are de ned recursively. Equality in the object language is here syntactic equality and is represented by the equality of the metalanguage. The second representation is a calculus of explicit substitutions. This is a pure inductive de nition and proofs of equalities are generated simultaneously. As for Curien's explicit syntax there are term constructors corresponding to applications of the type equality rules, and coherence conditions related to those appearing in category theory. We prove the equivalence of the two representations. This proof can be viewed as a solution of the coherence problem for the calculus of explicit substitutions.

This thesis presents a new algorithm for Normalisation by Evaluation for different type theories. This algorithm is later used to define a type-checking algorithm and to prove other meta-theoretical results about predicative type systems.

2001

this article we will not attempt to describe all the dierent possible choicesof type theories. Instead we want to discuss the main underlying ideas, with a specialfocus on the use of type theory as the formalism for the description of theoriesincluding proofs

Journal of Automated Reasoning

Types in higher-order logic (HOL) are naturally interpreted as nonempty sets. This intuition is reflected in the type definition rule for the HOL-based systems (including Isabelle/HOL), where a new type can be defined whenever a nonempty set is exhibited. However, in HOL this definition mechanism cannot be applied inside proof contexts. We propose a more expressive type definition rule that addresses the limitation and we prove its consistency. This higher expressive power opens the opportunity for a HOL tool that relativizes type-based statements to more flexible set-based variants in a principled way. We also address particularities of Isabelle/HOL and show how to perform the relativization in the presence of type classes.

Logic Colloquium 2006, 2001

We develop a general tool to formalize and reason about languages expressed using higher-order abstract syntax in a proof-tool based on type theory (Coq). A language is specified by its signature, which consists of sets of sort and operation names and typing rules. These rules prescribe the sorts and bindings of each operation. An algebra of terms is associated to a signature, using de Bruijn notation. Then a higher-order notation is built on top of the de Bruijn level, so that the user can work with meta-variables instead of de Bruijn indices. We also provide recursion and induction principles formulated directly on the higher-order syntax. This generalizes work on the Hybrid approach to higher-order syntax in Isabelle and our earlier work on a constructive extension to Hybrid formalized in Coq. In particular, a large class of theorems that must be repeated for each object language in Hybrid is done once in the present work and can be applied directly to each object language.

ACM SIGPLAN Notices, 2017

While type soundness proofs are taught in every graduate PL class, the gap between realistic languages and what is accessible to formal proofs is large. In the case of Scala, it has been shown that its formal model, the Dependent Object Types (DOT) calculus, cannot simultaneously support key metatheoretic properties such as environment narrowing and subtyping transitivity, which are usually required for a type soundness proof. Moreover, Scala and many other realistic languages lack a general substitution property. The first contribution of this paper is to demonstrate how type soundness proofs for advanced, polymorphic, type systems can be carried out with an operational semantics based on high-level, definitional interpreters, implemented in Coq. We present the first mechanized soundness proofs in this style for System F and several extensions, including mutable references. Our proofs use only straightforward induction, which is significant, as the combination of big-step semantics...

Lecture Notes in Computer Science, 2009

Rewriting logic semantics (RLS) was proposed as a programing language definitional framework that unifies operational and algebraic denotational semantics; see and the references there. Once a language is defined as an RLS theory, many generic tools are immediately available for use with no additional cost to the designer. These include a formal inductive theorem proving environment, an efficient interpreter, a state space explorer, and even a model checker. RLS has already been used to define a series of didactic and real languages .