87 research outputs found
DBGen User Manual
DBGen is a tool for Coq developers. It takes as input the definition of a
term structure with bindings annotations and generates definitions and
properties for lifting and substitution in the De Bruijn setting, up to the
substitution lemma. It provides also a named syntax and a translation function
to the De Bruijn syntax
LoopW Technical Reference v0.3
This document describes the implementation in SML of the LoopW language, an
imperative language with higher-order procedural variables and non-local jumps
equiped with a program logic. It includes the user manual along with some
implementation notes and many examples of certified imperative programs. As a
concluding example, we show the certification of an imperative program encoding
shift/reset using callcc/throw and a global meta-continuation
A Formally Specified Type System and Operational Semantics for Higher-Order Procedural Variables
We formally specified the type system and operational semantics of LOOPw with
Ott and Isabelle/HOL proof assistant. Moreover, both the type system and the
semantics of LOOPw have been tested using Isabelle/HOL program extraction
facility for inductively defined relations. In particular, the program that
computes the Ackermann function type checks and behaves as expected. The main
difference (apart from the choice of an Ada-like concrete syntax) with LOOPw
comes from the treatment of parameter passing. Indeed, since Ott does not
currently fully support alpha-conversion, we rephrased the operational
semantics with explicit aliasing in order to implement the out parameter
passing mode
Generic Environments in Coq
We introduce a library which provides an abstract data type of environments,
as a functor parameterized by a module defining variables, and a function which
builds environments for such variables with any Type of type. Usual operations
over environments are defined, along with an extensive set of basic and more
advanced properties. Moreover, we give an implementation using lists satisfying
all the required properties.Comment: 6 pages; The Third Coq Workshop (Coq'3), 201
A program logic for higher-order procedural variables and non-local jumps
Relying on the formulae-as-types paradigm for classical logic, we define a
program logic for an imperative language with higher-order procedural variables
and non-local jumps. Then, we show how to derive a sound program logic for this
programming language. As a by-product, we obtain a non-dependent type system
which is more permissive than what is usually found in statically typed
imperative languages. As a generic example, we encode imperative versions of
delimited continuations operators shift and reset
Deriving a Hoare-Floyd logic for non-local jumps from a formulae-as-types notion of control
We derive a Hoare-Floyd logic for non-local jumps and mutable higher-order
procedural variables from a formul{\ae}-as-types notion of control for
classical logic. The main contribution of this work is the design of an
imperative dependent type system for non-local jumps which corresponds to
classical logic but where the famous consequence rule is still derivable.Comment: The 22nd Nordic Workshop on Programming Theory, Turku : Finland
(2010
Needle & knot : binder boilerplate tied up
To lighten the burden of programming language mechanization, many approaches have been developed that tackle the substantial boilerplate which arises from variable binders. Unfortunately, the existing approaches are limited in scope. They typically do not support complex binding forms (such as multi-binders) that arise in more advanced languages, or they do not tackle the boilerplate due to mentioning variables and binders in relations. As a consequence, the human mechanizer is still unnecessarily burdened with binder boilerplate and discouraged from taking on richer languages.
This paper presents Knot, a new approach that substantially extends the support for binder boilerplate. Knot is a highly expressive language for natural and concise specification of syntax with binders. Its meta-theory constructively guarantees the coverage of a considerable amount of binder boilerplate for well-formed specifications, including that for well-scoping of terms and context lookups. Knot also comes with a code generator, Needle, that specializes the generic boilerplate for convenient embedding in COQ and provides a tactic library for automatically discharging proof obligations that frequently come up in proofs of weakening and substitution lemmas of type-systems.
Our evaluation shows, that Needle & Knot significantly reduce the size of language mechanizations (by 40% in our case study). Moreover, as far as we know, Knot enables the most concise mechanization of the POPLmark Challenge (1a + 2a) and is two-thirds the size of the next smallest. Finally, Knot allows us to mechanize for instance dependentlytyped languages, which is notoriously challenging because of dependent contexts and mutually-recursive sorts with variables
- …