670 research outputs found
Constraint Handling Rules with Binders, Patterns and Generic Quantification
Constraint Handling Rules provide descriptions for constraint solvers.
However, they fall short when those constraints specify some binding structure,
like higher-rank types in a constraint-based type inference algorithm. In this
paper, the term syntax of constraints is replaced by -tree syntax, in
which binding is explicit; and a new generic quantifier is introduced,
which is used to create new fresh constants.Comment: Paper presented at the 33nd International Conference on Logic
Programming (ICLP 2017), Melbourne, Australia, August 28 to September 1, 2017
16 pages, LaTeX, no PDF figure
Nominal Logic Programming
Nominal logic is an extension of first-order logic which provides a simple
foundation for formalizing and reasoning about abstract syntax modulo
consistent renaming of bound names (that is, alpha-equivalence). This article
investigates logic programming based on nominal logic. We describe some typical
nominal logic programs, and develop the model-theoretic, proof-theoretic, and
operational semantics of such programs. Besides being of interest for ensuring
the correct behavior of implementations, these results provide a rigorous
foundation for techniques for analysis and reasoning about nominal logic
programs, as we illustrate via examples.Comment: 46 pages; 19 page appendix; 13 figures. Revised journal submission as
of July 23, 200
A Bi-Directional Refinement Algorithm for the Calculus of (Co)Inductive Constructions
The paper describes the refinement algorithm for the Calculus of
(Co)Inductive Constructions (CIC) implemented in the interactive theorem prover
Matita. The refinement algorithm is in charge of giving a meaning to the terms,
types and proof terms directly written by the user or generated by using
tactics, decision procedures or general automation. The terms are written in an
"external syntax" meant to be user friendly that allows omission of
information, untyped binders and a certain liberal use of user defined
sub-typing. The refiner modifies the terms to obtain related well typed terms
in the internal syntax understood by the kernel of the ITP. In particular, it
acts as a type inference algorithm when all the binders are untyped. The
proposed algorithm is bi-directional: given a term in external syntax and a
type expected for the term, it propagates as much typing information as
possible towards the leaves of the term. Traditional mono-directional
algorithms, instead, proceed in a bottom-up way by inferring the type of a
sub-term and comparing (unifying) it with the type expected by its context only
at the end. We propose some novel bi-directional rules for CIC that are
particularly effective. Among the benefits of bi-directionality we have better
error message reporting and better inference of dependent types. Moreover,
thanks to bi-directionality, the coercion system for sub-typing is more
effective and type inference generates simpler unification problems that are
more likely to be solved by the inherently incomplete higher order unification
algorithms implemented. Finally we introduce in the external syntax the notion
of vector of placeholders that enables to omit at once an arbitrary number of
arguments. Vectors of placeholders allow a trivial implementation of implicit
arguments and greatly simplify the implementation of primitive and simple
tactics
Polymorphic Typestate for Session Types
Session types provide a principled approach to typed communication protocols
that guarantee type safety and protocol fidelity. Formalizations of
session-typed communication are typically based on process calculi, concurrent
lambda calculi, or linear logic. An alternative model based on
context-sensitive typing and typestate has not received much attention due to
its apparent restrictions. However, this model is attractive because it does
not force programmers into particular patterns like continuation-passing style
or channel-passing style, but rather enables them to treat communication
channels like mutable variables. Polymorphic typestate is the key that enables
a full treatment of session-typed communication. Previous work in this
direction was hampered by its setting in a simply-typed lambda calculus. We
show that higher-order polymorphism and existential types enable us to lift the
restrictions imposed by the previous work, thus bringing the expressivity of
the typestate-based approach on par with the competition. On this basis, we
define PolyVGR, the system of polymorphic typestate for session types,
establish its basic metatheory, type preservation and progress, and present a
prototype implementation.Comment: 29 pages. Short version appears in PPDP 202
Investigations in intersection types : confluence, and semantics of expansion in the -calculus, and a type error slicing method
Type systems were invented in the early 1900s to provide foundations for Mathematics
where types were used to avoid paradoxes. Type systems have then been
developed and extended throughout the years to serve different purposes such as efficiency
or expressiveness. The λ-calculus is used in programming languages, logic,
mathematics, and linguistics. Intersection types are a kind of types used for building
semantic models of the λ-calculus and for static analysis of computer programs.
The confluence property was used to prove the λ-calculus’ consistency and the
uniqueness of normal forms. Confluence is useful to show that logics are sensibly
designed, and to make equality decision procedures for use in theorem provers.
Some proofs of the λ-calculus’ confluence are based on syntactic concepts (reduction
relations and λ-term sets) and some on semantic concepts (type interpretations).
Part I of this thesis presents an original syntactic proof that is a simplification of
a semantic proof based on a sound type interpretation w.r.t. an intersection type
system. Our proof can be seen as bridging some semantic and syntactic proofs.
Expansion is an operation on typings (pairs of type environments and result
types) in type systems for the λ-calculus. It was introduced to prove that the principal
typing property (i.e., that every typable term has a strongest typing) holds
in intersection type systems. Expansion variables were introduced to simplify the
expansion mechanism. Part II of this thesis presents a complete realisability semantics
w.r.t. an intersection type system with infinitely many expansion variables.
This represents the first study on semantics of expansion. Providing sound (and
complete) realisability semantics allows one to study the algorithmic behaviour of
typed λ-terms through their types w.r.t. a type system. We believe such semantics
will cast some light on the not yet well understood expansion operation.
Intersection types were used in a type error slicer for the SML programming
language. Existing compilers for many languages have confusing type error messages.
Type error slicing (TES) helps the programmer by isolating the part of a program
contributing to a type error (a slice). TES was initially done for a tiny toy language
(the λ-calculus with polymorphic let-expressions). Extending TES to a full language
is extremely challenging, and for SML we needed a number of innovations. Some
issues would be faced for any language, and some are SML-specific but representative
of the complexity of language-specific issues likely to be faced for other languages.
Part III of this thesis solves both kinds of issues and presents an original, simple,
and general constraint system for providing type error slices for ill-typed programs.
We believe TES helps demystify language features known to confuse users
A type- and scope-safe universe of syntaxes with binding: their semantics and proofs
Almost every programming language's syntax includes a notion of binder and corresponding bound occurrences, along with the accompanying notions of alpha-equivalence, capture-avoiding substitution, typing contexts, runtime environments, and so on. In the past, implementing and reasoning about programming languages required careful handling to maintain the correct behaviour of bound variables. Modern programming languages include features that enable constraints like scope safety to be expressed in types. Nevertheless, the programmer is still forced to write the same boilerplate over again for each new implementation of a scope safe operation (e.g., renaming, substitution, desugaring, printing, etc.), and then again for correctness proofs. We present an expressive universe of syntaxes with binding and demonstrate how to (1) implement scope safe traversals once and for all by generic programming; and (2) how to derive properties of these traversals by generic proving. Our universe description, generic traversals and proofs, and our examples have all been formalised in Agda and are available in the accompanying material available online at https://github.com/gallais/generic-syntax
Elaborator reflection : extending Idris in Idris
Many programming languages and proof assistants are defined by elaboration from a high-level language with a great deal of implicit information to a highly explicit core language. In many advanced languages, these elaboration facilities contain powerful tools for program construction, but these tools are rarely designed to be repurposed by users. We describe elaborator reflection, a paradigm for metaprogramming in which the elaboration machinery is made directly available to metaprograms, as well as a concrete realization of elaborator reflection in Idris, a functional language with full dependent types. We demonstrate the applicability of Idris’s reflected elaboration framework to a number of realistic problems, we discuss the motivation for the specific features of its design, and we explore the broader meaning of elaborator reflection as it can relate to other languages.Postprin
- …