Sorry for the gap in posts. I’ve been trying to post more regularly, and was just hitting a rhythm, when my son brought home a particularly vicious bug, and I got sick. I’ve spent the last couple of weeks being really, really sick, and then trying to get caught up at work. I’m mostly recovered, except for some lingering asthma, so I’m trying to get back to that twice-per-week posting schedule.

In the last couple of posts, we looked at Martin-Löf’s theory of expressions. The theory of expressions is purely syntactic: it’s a way of understanding the notation of expressions. Everything that we do in type theory will be written with expressions that follow the syntax, the arity, and the definitional equivalency rules of expression theory.

The next step is to start to understand the *semantics* of expressions. In type theory, when it comes to semantics, we’re interested in two things: *evaluation* and *judgements*. Evaluation is the process by which an expression is reduced to its simplest form. It’s something that we care about, but it’s not really a focus of type theory: type theory largely waves its hands in the air and says “we know how to do this”, and opts for normal-order evaluation. Judgements are where things get interesting.

Judgements are provable statements about expressions and the values that they represent. As software people, when we think about types and type theory, we’re usually thinking about type declarations: type declarations are judgements about the expressions that they apply to. When you write a type declaration in a programming language, what you’re doing is asserting the type theory judgement. When the compiler “type-checks” your program, what it’s doing in type theory terms is checking that your judgements are proven by your program.

For example, we’d like to be able to make the judgement `A set`

– that is, that A is a set. In order to make the judgement that A is a set in type theory, we need to know two things:

- How are canonical instances of the set A formed?
- Given two canonical instances of A, how can we determine if they’re equal?

To understand those two properties, we need to take a step back. What is a *canonical* instance of a set?

If we think about how we use predicate logic, we’re always given some basic set of facts as a starting point. In type theory, the corresponding concept is a *primitive constant*. The primitive constants include base values *and* primitive functions. For example, if we’re working with lispish expressions, then `cons(1, cons(2, nil))`

is an expression, and `cons`

, `nil`

, `1`

and `2`

are primitive constants; `cons`

is the *head* of the expression, and `1`

and `cons(2, nil)`

are the arguments.

A canonical expression is a saturated, closed expression whose head is a primitive constant.

The implications of this can be pretty surprising, because it means that a canonical expression can contain unevaluated arguments! The expression has to be saturated and closed – so its arguments can’t have unbound variables, or be missing parameters. But it can contain unevaluated subexpressions. For example, if we were working with Peano arithmetic in type theory, `succ(2+3)`

is canonical, even though “2+3” hasn’t be evaluated.

In general, in type theory, the way that we evaluate an expression is called *normal order* evaluation – what programming language people call *lazy evaluation*: that’s evaluating from the outside in. Given a non-canonical expression, we evaluate from the outside in until we get to a canonical expression, and then we stop. A canonical expression is considered the result of a computation – so we can see `succ(2+3)`

as a result!

A canonical expression is the *evaluated* form of an expression, but not the *fully evaluated* form. The fully evaluated form is when the expression and all of its saturated parts are fully evaluated. So in our previous example, the saturated part `2+3`

wasn’t evaluated, so it’s not fully evaluated. To get it to be fully evaluated, we’d need to evaluate `2+3`

, giving us `succ(5)`

; then, since `succ(5)`

is saturated, it’s evaluated to `6`

, which is the fully evaluated form of the expression.

Next post (coming monday!), we’ll use this new understanding of canonical expressions, and start looking at judgements, and what they mean. That’s when type theory starts getting really fun and interesting.