When the philosopher Bertrand Russell invented type theory at the beginning of the 20th century, he could hardly have imagined that his solution to a simple logic paradox—defining the set of all sets not in themselves—would one day shape the trajectory of 21st century computer science.

It is riddled with misconceptions, errors, and self-aggrandizement. It does us the great disservice of conflating (dynamic) memory safety and (static) type safety, and has whoppers like “A type system ensures the correct behavior of any program routine by enforcing a set of predetermined behaviors,” which is just false. But hey, ra-ra types! No?

• Typed and untyped lambda-calculi as models of computation.
• Proof-theory: Natural deduction, sequent calculi, cut elimination and normalization. Propositions as types, linear logic and proof nets.
• Semantics: Denotational semantics, game semantics, realizability, categorical models.
• Programming languages: Foundations of functional and object-oriented programming, proof search, logic programming, type checking.
• Implementation: Abstract machines, parallel execution, optimal reduction, program optimization.

The problems are all interesting. I liked 6, 8, 12-14, 16-18 in particular.

As a consequence, while the compiler does not explicitly reduce [...] expressions to normal form, hence computing an “answer,” its type inference mechanism implicitly carries out that reduction to normal form, expressed in the language of first-order unification.

This insight becomes the key ingredient in proving the lower bound complexity of simple type inference—when our program is linear, static analysis is effectively “running” the program. Lower bounds, then, can be obtained by simply hacking within the linear λ-calculus.

In this note, I just want to look a bit more closely at the problem of “reading back” a normal form from a given type for a linear term. It’s not exactly spelled out and I had to think about what the readback algorithm would actually look like.

In general, we have a type σ₁ → σ₂ … → σ_k → A, where A is a type variable. So what do we know about the normal form? It has to have the shape λx₁.λx₂…λx_k.[---]. Since the term is linear, and the type is most general, every type variable occurs exactly twice: once positively and once negatively (convince yourself of this in the privacy of your own home). Furthermore, there exists a unique σ_i ≡ τ₁ → τ₂ … → τ_m → A, so… x_i must be the head variable of the normal form, ie., we now know: λx₁.λx₂…λx_i…λx_k.x_i[---], and x_i is applied to m arguments, each with type τ₁, …, τ_m, respectively. But now we can recursively construct the normal forms of the arguments and we’re done. We hit the base case when we get to a base type (a type variable); here the term is just the occurrence of the λ-bound variable that has this type.

Let’s look at a concrete example. There are two linear functions on pairs: identity and twist, so we have as normal forms:

• λc.λp.λq.cpq = Id
• λc.λp.λq.cqp = Twist

These are the basic building blocks of the Mairson encodings of the Booleans, which are linear, unlike the Church encodings that are linear-affine (each bound variable occurs at most once). True is a pair of functions on pairs—the first is identity, the second is a twist (swap the car and cdr). False, likewise, is a pair of function on pairs, but it has twist in the first component and identity in the second. The most general types for Id and Twist are the following (if you don’t believe me, just fire up your ML interpreter):

• λc.λp.λq.cpq : (A → B → C) → A → B → C
• λc.λp.λq.cqp : (A → B → C) → B → A → C

Notice each type variable occurs exactly twice, once positively, once negatively. Now let’s look only at the types and readback the above normal forms. In the case of (A → B → C) → A → B → C, we have σ₁ → σ₂ → σ₃ → C, so we know the term has the shape λx₁.λx₂.λx₃.[---]. There is a unique σ_i ending in C, namely σ₁ = A → B → C, so x₁ is the head variable and it takes two arguments: λx₁.λx₂.λx₃.x₁[---][---]. The first argument has type A, so it must be x₂ and the second argument has type B, so it must be x₃. So we have λx₁.λx₂.λx₃.x₁x₂x₃ ≡_α λc.λp.λq.cpq.

In the case of (A → B → C) → B → A → C, by the same steps we get to λx₁.λx₂.λx₃.x₁[---][---], but the first argument has type B and the second argument has type A, so the normal form is λx₁.λx₂.λx₃.x₁x₃x₂ ≡_α λc.λp.λq.cqp.

For a more complicated example, try reading back the normal forms of Mairson’s True and False from the following types:

• (((A → B → C) → A → B → C) → ((D → E → F) → E → D → F) → G) → G
• (((A → B → C) → B → A → C) → ((D → E → F) → D → E → F) → G) → G

There is also a pretty straightforward way of seeing how to do this via a proofs-as-programs correspondence between linear λ-terms and multiplicative linear logic proofs, but that’s a story for another day.

• [2004,article] bibtex
  H. G. Mairson, "Linear lambda calculus and PTIME-completeness," J. Funct. Program., vol. 14, iss. 6, pp. 623-633, 2004.
  @ARTICLE{mairson_linear_lambda_ptime,
  author = {Harry G. Mairson},
  title = {Linear lambda calculus and PTIME-completeness},
  journal = {J. Funct. Program.},
  volume = {14},
  number = {6},
  year = {2004},
  issn = {0956-7968},
  pages = {623--633},
  doi = {http://dx.doi.org/10.1017/S0956796804005131},
  publisher = {Cambridge University Press},
  address = {New York, NY, USA},
  }