Lecture 6: Encoding of $\lambda$-calculus, System T & System F

• $\mathtt{\text{in}}$
• $\mathtt{\text{let fix}}$

Sytem F:

• $\lambda$
• $\mathtt{\text{app}}$

OCamL:

type d =
    Lam of d -> d

(* Or with GADT: *)
Lam: (d -> d) -> d

• fun
• application (no symbol)
• Lam
• match

Coq:

Inductive D :=
    Lam: (D -> D) -> D

• fun
• application (no symbol)
• Lam
• match

Find a term $t$ such that, for $f:D⟶D$:

We will write the $Y$-combinator:

The thing is:

Untyped $\lambda$-calculus = Simply-typed $\lambda$-calculus + Coercion $D=D⟶D$

We already have $Lam:(D\to D)\to D$, so all we have to do is to construct a term

We will use the match of Coq (Coq = the meta-language):

app := fun x:D =>
            fun y:D =>
                match x with
                    | Lam f => f y

so that app (Lam f) y = f y

Now:

δ := Lam (fun x => app x x)
Ω := app δ δ

δ' := Lam (fun f => Lam (fun x => app f (app x x)))
Y := Lam (fun f => app (app δ' f) (app δ' f))

In the definition of $\mu X.A$, $X$ should occur strictly positively, i.e. only in the indicated position of $P$.

Inductive tree (A: Type) :=
    Node: A -> (nat -> tree A) -> tree A
    Leaf: A -> tree A

We can have element which haven’t a bounded depth.

Other example:

Inductive I :=
    C : ((I -> nat) -> nat) -> I

⟶ The first I is in a positive, but not strictly positive, position.

Postive/Negative positions

• $X$ occurs strictly positively in $X$
• if $X$ occurs positively in $A$, then $X$ occurs negatively in $\prod _{x:A}B$
• if $X$ occurs negatively in $B$, then $X$ occurs positively in $\prod _{x:A}B$
• if $X$ occurs stricly positively in $A$ then it occurs positively in $A$

NB:

$\otimes$ (the tensor product of linear logic):

• Constructor: $(t,u)$

• Destructor:

    match t with
        (x, y) => x (* pattern *)
    end
  

• has an $\eta$ rule on the side of the match destructor: ${\eta }_{\otimes }:\mathtt{\text{match }}t\mathtt{\text{ with }}(x,y)⟶E(x,y)\mathtt{\text{end}}=E[t]$

  where $E$ is an evaluation context (a term with a hole)

$\mathrm{\&}$ (the “with” of linear logic):

• Constructor: $\{fst=t;snd=u\}$ ⟶ definition by co-pattern
• Destructor: $fst,snd$

• has an $\eta$ rule on the side of the match constructor:

  $${\eta }_{\mathrm{\&}}:t=\{fst=fstt;snd=sndt\}$$

match (t, u) with
    (x, y) => v
end.

⟶ v[t/x][u/y]

cf. “Linear intuitionistic logic” by Nick Benton

Inductive L (A: Type): Type :=
    Var : A -> LA
    App : LA -> LA -> LA
    Lam : L (option A) -> LA  (* recursively non uniform parameter of inductive type *)

where

Inductive option (A: Type): Type :=
    None : option A
    Some : A -> option A

and

Inductive False := .

Show that simply-typed $\lambda$-terms can be encoded in the type L False and encode $\lambda x,y.x$ and $\lambda f,x.f(fx)$

Var : False -> L False
App : L False -> L False -> L False
Lam : L (option False) -> L False

• $x^A\stackrel{\scriptscriptstyle\mathrm{def}}{=}$ Var

Another interesting “high-tech” type:

Inductive tree (A: Type) :=
    Node : tree (tree A) -> tree A
    Leaf : A -> tree A

System T and System F

System T:

is the language if terms canonically associated to $P{A}_1$

System F:

is the language if terms canonically associated to $P{A}_2$

Types of system F:

it’s the ones of simply-typed $\lambda$-calculus + second order quantification:

$$A,B\stackrel{\scriptscriptstyle\mathrm{def}}{=}A\to B\mid \forall X.A\mid X$$

Terms of system F:

$$t,u\stackrel{\scriptscriptstyle\mathrm{def}}{=}a\mid \lambda a.t\mid tu\mid \lambda X.t\mid tA$$

Typing rules:

NB: System F encompasses System T, and is even much more powerful.

Church encoding of natural numbers

NB: Kleene found the expression of the predecessor at the dentist’s.

Problem: the predecessor is computed in linear time, which is annoying: we would like to have it in constant time. That’s part of the reason why inductive types became so successful, in comparison.

Curryfication

Right Kan extension (${\int }_X$)

Left Kan extension (${\int }^X$)