# A Twelf Introduction

For the last 3 or so weeks I’ve been writing a bunch of Twelf code for my research (hence my flat-lined github punch card). Since it’s actually a lot of fun I thought I’d share a bit about Twelf.

## What Is Twelf

Since Twelf isn’t a terribly well known language it’s worth stating what exactly it is we’re talking about. Twelf is a proof assistant. It’s based on a logic called LF (similarly to how Coq is based on CiC).

Twelf is less powerful than some other proof assistants but by limiting some of its power it’s wonderfully suited to proving certain types of theorems. In particular, Twelf admits true “higher order abstract syntax” (don’t worry if you don’t know what this means) this makes it great for formalizing programming languages with variable bindings.

In short, Twelf is a proof assistant which is very well suited for defining and proving things about programming languages.

## Getting Twelf

It’s much more fun to follow along a tutorial if you actually have a Twelf installation to try out the code. You can download and compile the sources to Twelf with SML/NJ or Mlton. You could also use smackage to get the compiler.

Once you’ve compiled the thing you should be left with a binary `twelf-server`

. This is your primary way of interacting with the Twelf system. There’s quite a slick Emacs interface to smooth over this process. If you’ve installed twelf into a directory `~/twelf/`

all you need is the incantation

```
(setq twelf-root "~/twelf/")
(load (concat twelf-root "emacs/twelf-init.el"))
```

Without further ado, let’s look at some Twelf code.

## Some Code

When writing Twelf code we encode the thing that we’re studying, the object language, as a bunch of type families and constructors in Twelf. This means that when we edit a Twelf file we’re just writing signatures.

For example, if we want to encode natural numbers we’d write something like

```
nat : type.
z : nat.
s : nat -> nat.
```

This is an LF signature, we declare a series of constants with `NAME : TYPE.`

. Note the period at the end of each declaration. First we start by declaring a type for natural numbers called `nat`

with `nat : type.`

Here `type`

is the base kind of all types in Twelf. Next we go on to declare what the values of type `nat`

are.

In this case there are two constructors for `nat`

. We either have zero, `z`

, or the successor of another value of type `nat`

, `s`

. This gives us a canonical forms lemma for natural numbers: All values of type `nat`

are either

`z`

`s N`

for some value`N : nat`

Later on, we’ll justify the proofs we write with this lemma.

Anyways, now that we’ve encoded the natural numbers I wanted to point out a common point of confusion about Twelf. We’re not writing programs to be run. We’re writing programs exclusively for the purpose of typechecking. Heck, we’re not even writing programs at the term level! We’re just writing a bunch of constants out with their types! More than this even, Twelf is defined so that you can only write canonical forms. This means that if you write something in your program, it has to be in normal form, fully applied! In PL speak it has to be β-normal and η-long. This precludes actually writing programs for the sake of reducing them. You’re never going to write a web server in Twelf, you even be writing “Hello World”. You might use it to verify the language your writing them in though.

Now that we’ve gotten the awkward bit out the way, let’s now define a Twelf encoding of a judgment. We want to encode the judgment `+`

which is given by the following rules

```
—————————
z + n = n
m + n = p
———————————————
s(m) + n = s(p)
```

In the rest of the world we have this idea that propositions are types. In twelf, we’re worried about defining logics and systems, so we have the metatheoretic equivalent: judgments are types.

So we define a type family `plus`

.

` plus : nat -> nat -> nat -> type`

So `plus`

is a type indexed over 3 natural numbers. This is our first example of dependent types: `plus`

is a type which *depends* on 3 terms. Now we can list out how to construct a derivation of `plus`

. This means that inference rules in a meta theory corresponds to constants in Twelf as well.

` plus/z : {n : nat} plus z n n`

This is some new syntax, in Twelf `{NAME : TYPE} TYPE`

is a dependent function type, a pi type. This notation is awfully similar to Agda and Idris if you’re familiar with them. This means that this constructor takes a natural number, `n`

and returns a derivation that `plus z n n`

. The fact that the return type depends on what `nat`

we supply is why this needs a dependent type.

In fact, this is such a common pattern that Twelf has sugar for it. If we write an unbound capital variable name Twelf will automagically introduce a binder `{N : ...}`

at the front of our type. We can thus write our inference rules as

```
plus/z : plus z N N
plus/s : plus N M P -> plus (s N) M (s P)
```

These rules together with our declaration of `plus`

. In fact, there’s something kinda special about these two rules. We know that for any term `n : nat`

which is in canonical form, there should be an applicable rule. In Twelf speak, we say that this type family is total.

We can ask Twelf to check this fact for us by saying

```
plus : nat -> nat -> nat -> type.
%mode plus +N +M -P.
plus/z : plus z N N.
plus/s : plus N M P -> plus (s N) M (s P).
%worlds () (plus _ _ _).
%total (N) (plus N _ _).
```

We want to show that for all terms `n, m : nat`

in canonical form, there is a term `p`

in canonical form so that `plus n m p`

. This sort of theorem is what we’d call a ∀∃-theorem. This is literally because it’s a theorem of the form “∀ something. ∃ something. so that something”. These are the sort of thing that Twelf can help us prove.

Here’s the workflow for writing one of these proofs in Twelf

- Write out the type family
- Write out a
`%mode`

specification to say what is bound in the ∀ and what is bound in the ∃. - Write out the different constants in our type family
- Specify the context to check our proof in with
`%worlds`

, usually we want to say the empty context,`()`

- Ask Twelf to check that we’ve created a proof according to the mode with
`%total`

where the`N`

specifies what to induct on.

In our case we have a case for each canonical form of `nat`

so our type family is total. This means that our theorem passes. Hurray!

Believe it or not this is what life is like in Twelf land. All the code I’ve written these last couple of weeks is literally type signatures and 5 occurrences of `%total`

. What’s kind of fun is how unreasonably effective a system this is for proving things.

Let’s wrap things up by proving one last theorem, if `plus A B N`

and `plus A B M`

both have derivations, then we should be able to show that `M`

and `N`

are the same. Let’s start by defining what it means for two natural numbers to be the same.

```
nat-eq : nat -> nat -> type.
nat-eq/r : nat-eq N N.
nat-eq/s : nat-eq N M -> nat-eq (s N) (s M).
```

I’ve purposefully defined this so it’s amenable to our proof, but it’s still a believable formulation of equality. It’s reflexive and if `N`

is equal to `M`

, then `s N`

is equal to `s M`

. Now we can actually state our proof.

```
plus-fun : plus N M P -> plus N M P' -> nat-eq P P' -> type.
%mode plus-fun +A +B -C.
```

Our theorem says if you give us two derivations of `plus`

with the same arguments, we can prove that the outputs are equal. There are two cases we have to cover for our induction so there are two constructors for this type family.

```
plus-fun/z : plus-fun plus/z plus/z nat-eq/r.
plus-fun/s : plus-fun (plus/s L) (plus/s R) (nat-eq/s E)
<- plus-fun L R E.
```

A bit of syntactic sugar here, I used the backwards arrow which is identical to the normal `->`

except its arguments are flipped. Finally, we ask Twelf to check that we’ve actually proven something here.

```
%worlds () (plus-fun _ _ _).
%total (P) (plus-fun P _ _).
```

And there you have it, some actual theorem we’ve mechanically checked using Twelf.

## Wrap Up

I wanted to keep this short, so now that we’ve covered Twelf basics I’ll just refer you to one of the more extensive tutorials. You may be interested in

If you’re interested in learning a bit more about the nice mathematical foundations for LF you should check out “The LF Paper”.

comments powered by Disqus