Abstract—A core programming language is presented that allows structural recursion over open LF objects and contexts. The main technical tool is a coverage checking algorithm that also generates valid recursive calls. Termination of call-by-value reduction is proven using a reducibility semantics. This establishes consistency and allows the implementation of proofs about LF specifications as well-founded recursive functions using simultaneous pattern matching. I.

Abstract not found

When defining computations over syntax as data, one often runs into tedious issues concerning α-equivalence and semantically correct manipulations of binding constructs. Here we study a semantic framework in which these issues can be dealt with automatically by the programming language. We take the user-friendly ‘nominal’ approach in which bound objects are named. In particular, we develop a version of Scott domains within nominal sets and define two programming languages whose denotational semantics are based on those domains. The first language, λν-PCF, is an extension of Plotkin’s PCF with names that can be swapped, tested for equality and locally scoped; although simple, it already exposes most of the se-mantic subtleties of our approach. The second language, PNA, extends the first with name abstraction and concretion so that it can be used for metaprogramming over syntax with binders. For both languages, we prove a full abstraction result for nominal Scott domains analogous to Plotkin’s classic result about PCF and conventional Scott domains: two program phrases have the same observable operational behaviour in all contexts if and only if they denote equal elements of the nominal Scott domain model. This is the first full abstraction result we know of for languages combining higher-order functions with some form of locally scoped names which uses a domain theory based on ordinary extensional functions, rather than using the more intensional approach of game semantics.

Abstract. belugais a proof environment that provides a rich sophisti-cated infrastructure for implementing formal systems based on the log-ical framework LF together with a first-order reasoning language for implementing inductive proofs about them following the Curry-Howard isomorphism. In this paper we describe four significant extensions to beluga: 1) we enrich our infrastructure for modelling formal systems with first-class simultaneous substitutions, a key and common concept when reasoning about formal systems 2) we support inductive definitions in our reason-ing language that significantly increases beluga’s expressive power 3) we provide a totality checker that guarantees that recursive programs are well-founded and correspond to inductive proofs 4) we describe an interactive program development environment. Taken together these ex-tensions enable direct and compact mechanizations. To demonstrate bel-uga’s strength and illustrate these new features we develop a weak nor-malization proof using logical relations.

We present a core programming language that supports writing well-founded structurally recurs-ive functions using simultaneous pattern matching on contextual LF objects and contexts. The main technical tool is a coverage checking algorithm that also generates valid recursive calls. To establish consistency, we define a call-by-value small-step semantics and prove that every well-typed program terminates using a reducibility semantics. Based on the presented methodo-logy we have implemented a totality checker as part of the programming and proof environment Beluga where it can be used to establish that a total Beluga program corresponds to a proof.

Dependently typed programming languages allow programmers to express a rich set of invariants and verify them statically via type checking. To make programming with dependent types practical, dependently typed systems provide a compact language for pro-grammers where one can omit some arguments, called implicit, which can be inferred. This source language is then usually elab-orated into a core language where type checking and fundamen-tal properties such as normalization are well understood. Unfor-tunately, this elaboration is rarely specified and in general is ill-understood. This makes it not only difficult for programmers to un-derstand why a given program fails to type check, but also is one of the reasons that implementing dependently typed programming systems remains a black art known only to a few. In this paper, we specify the design of a source language for a dependently typed programming language where we separate the language of programs from the language of types and terms occur-ring in types. We then give a bi-directional elaboration algorithm to translate source terms where implicit arguments can be omitted to a fully explicit core language and prove soundness of our elabora-tion. Our framework provides post-hoc explanation for elaboration found in the programming and proof environment, Beluga. Categories and Subject Descriptors CR-number [subcategory]: third-level