Slides to go with the video here: https://www.youtube.com/watch?v=ZGqKsalJi4s

1. Pure Type Systems:
Dependents When You Need Them
Cody Roux
Draper Laboratories
February 17, 2015
Cody Roux (Draper Labs) PTSes February 17, 2015 1 / 38

2. Introduction
This talk is not about Haskell!
Cody Roux (Draper Labs) PTSes February 17, 2015 2 / 38

3. Introduction
Or is it?
Wait, which Haskell?
good ol’ Haskell 98
-XTypeFamilies
-XExistentialQuantification
-XRank2Types
-XRankNTypes
-XDataKinds
-XPolyKinds
-XGADTs
-XConstraintKinds
-XImpredicativeTypes
etc.
Cody Roux (Draper Labs) PTSes February 17, 2015 3 / 38

4. Introduction
This talk is about abstraction!
We want to understand -XFooBar in a unified framework
Cody Roux (Draper Labs) PTSes February 17, 2015 4 / 38

5. Abstraction
The simplest form of abstraction
We have an expression 2 + 2
We can abstract it as x + x where x = 2
Have we gained anything?
Cody Roux (Draper Labs) PTSes February 17, 2015 5 / 38

6. Abstraction
We can form the λ-abstraction
λx. x + x
This is already a very powerful idea!
Cody Roux (Draper Labs) PTSes February 17, 2015 6 / 38

7. STLC
The Simply Typed λ-Calculus
Some base types A, B, C, ...
Higher-order functions λx.λf .f x : A → (A → B) → B
A small miracle: every function is terminating.
Cody Roux (Draper Labs) PTSes February 17, 2015 7 / 38

8. Polymorphism
We want to have polymorphic functions
(λx.x) 3 → 3
(λx.x) true → true
How do we add this feature?
Cody Roux (Draper Labs) PTSes February 17, 2015 8 / 38

9. Polymorphic formulas
There are 2 possible answers!
First
Add type-level variables, X, Y , Z, ...
Add polymorphic quantification
∀X.X → X
Cody Roux (Draper Labs) PTSes February 17, 2015 9 / 38

10. Polymorphic formulas
What does ∀X.T quantify over?
1 Only the simple types
2 Any type from the extended language
These lead to dramatically different systems!
In the first case, the extension is conservative (no “new” functions)
In the second case, it is not (system F)
Cody Roux (Draper Labs) PTSes February 17, 2015 10 / 38

11. Dependent types
We can add term-level information to types:
[1, 2, 3] : ListN
[1, 2, 3] : VecN 3
We can add quantification as well:
reverse : ∀n, VecN n → VecN n
When is this kind of dependency conservative?
Cody Roux (Draper Labs) PTSes February 17, 2015 11 / 38

12. Pure Type Systems
Pure type systems:
are a generic framework for logics/programming lang.
only allow universal quantification/dependent function space
Cody Roux (Draper Labs) PTSes February 17, 2015 12 / 38

13. Pure Type Systems
Pure type systems are:
1 Expressive: ∃ a PTS that can express set theory
2 Well studied: invented in the 80s (Barendregt) and studied ever since!
3 Flexible: found at the core of several functional languages, including
Haskell, Agda, Coq.
4 Can be complex! There are several longstanding open questions
including
1 Typed Conversion ⇔ Untyped Conversion
2 Weak Normalization ⇔ Strong Normalization
Cody Roux (Draper Labs) PTSes February 17, 2015 13 / 38

14. Pure Type Systems
Can we answer our questions using PTS?
Cody Roux (Draper Labs) PTSes February 17, 2015 14 / 38

15. Pure Type Systems
A Pure Type System is defined as
1 A set of Sorts S
2 A set of Axioms A ⊆ S × S
3 A set of Rules R ⊆ S × S × S
That’s it!
Cody Roux (Draper Labs) PTSes February 17, 2015 15 / 38

16. Pure Type Systems
Informally
Elements ∗, , ι, ... ∈ S represent a category of objects.
For example
∗ may represent the category of propositions
may represent the category of types
ι may represent the category of natural numbers
Cody Roux (Draper Labs) PTSes February 17, 2015 16 / 38

17. Pure Type Systems
(s1, s2) ∈ A informally means:
s1 is a member of the category s2
Cody Roux (Draper Labs) PTSes February 17, 2015 17 / 38

18. Pure Type Systems
(s1, s2, s3) ∈ R informally means:
Quantifying over an element of s2 parametrized over an element of s1
gives a result in s3
if A : s1 and B(x) : s2 when x : A
then ∀x : A.B(x) : s3
We will write Πx : A.B instead of ∀x : A.B(x) (tradition)
Cody Roux (Draper Labs) PTSes February 17, 2015 18 / 38

19. Pure Type Systems
Given a PTS P we have the following type system:
Type/Sort formation
Γ ⊢axiom (s1, s2) ∈ A
Γ ⊢ s1 : s2
Γ ⊢ A : s1 Γ, x : A ⊢ B : s2
prod (s1, s2, s3) ∈ R
Γ ⊢ Πx : A.B : s3
Cody Roux (Draper Labs) PTSes February 17, 2015 19 / 38

20. Pure Type Systems
Term formation
Γ ⊢ A : svar s ∈ S
Γ, x : A ⊢ x : A
Γ, x : A ⊢ t : B Γ ⊢ Πx : A.B : s
abs s ∈ S
Γ ⊢ λx : A.t : Πx : A.B
Γ ⊢ t : Πx : A.B Γ ⊢ u : Aapp
Γ ⊢ t u : B[x → u]
Cody Roux (Draper Labs) PTSes February 17, 2015 20 / 38

21. Pure Type Systems
Conversion
Γ ⊢ t : A Γ ⊢ A′ : sconv A ≃β A′
, s ∈ S
Γ ⊢ t : A′
Where ≃β is β-equality
(λx : A.t)u ≃β t[x → u]
We omit the boring rules...
Cody Roux (Draper Labs) PTSes February 17, 2015 21 / 38

22. Pure Type Systems
The rest of this talk
Understanding this definition!
Cody Roux (Draper Labs) PTSes February 17, 2015 22 / 38

23. Simply Typed Lambda Calculus
We can model the STLC using
S = {∗, }
A = {(∗, )}
R = {(∗, ∗, ∗)}
We have e.g.
A : ∗ ⊢ λx : A.x : A → A
taking A → A = Πx : A. A
Cody Roux (Draper Labs) PTSes February 17, 2015 23 / 38

24. The λ-cube
Some more examples, contained in a family called the λ-cube:
The sorts are ∗,
∗ :
The rules are (k1, k2, k2) with ki = ∗ or
Each dimension of the cube highlights a different feature
Cody Roux (Draper Labs) PTSes February 17, 2015 24 / 38

25. The λ-cube
STLC
F
λΠ
λ2
λω
Fω
λΠω
CC
Cody Roux (Draper Labs) PTSes February 17, 2015 25 / 38

26. λ-cube
STLC = (∗, ∗)
F = (∗, ∗) ( , ∗)
λω = (∗, ∗) ( , )
λΠ = (∗, ∗) (∗, )
λ2 = (∗, ∗) (∗, ) ( , ∗)
Fω = (∗, ∗) ( , ∗) ( , )
λΠω = (∗, ∗) (∗, ) ( , )
CC = (∗, ∗) (∗, ) ( , ∗) ( , )
STLC
F
λΠ
λ2
λω
Fω
λΠω
CC
Cody Roux (Draper Labs) PTSes February 17, 2015 26 / 38

27. λ-cube features
Calculus Rule Feature Example
STLC (∗, ∗) Ordinary (higher-order) functions id : N → N
F ( , ∗) Impredicative polymorphism id : ∀X.X → X
λω ( , ) Type constructors rev : List A → List A
λΠ (∗, ) Dependent Types head : VecN (n + 1) → N
Cody Roux (Draper Labs) PTSes February 17, 2015 27 / 38

28. Example
Let’s work out an example in CC:
Induction on lists
∀A P l, P (nil A) → (∀a r, P r → P (cons A y r)) → P l
Π(A: ∗)(P : List A → ∗)(l : List A). P (nil A) → Π(a : A)(r : List A). P r → P (cons A y r) → P l
X → Y still means Π : A. B
Whiteboard time!
Cody Roux (Draper Labs) PTSes February 17, 2015 28 / 38

29. Example
No whiteboard?
List : ∗ → ∗
nil : ΠA : ∗. List A
cons : ΠA : ∗. A → List A → List A
Cody Roux (Draper Labs) PTSes February 17, 2015 29 / 38

30. Example
⊢ ∗ :
A: ∗ ⊢ List A : ∗ . . . ⊢ ∗ :
A: ∗ ⊢ List A → ∗ :
. . . ⊢ P (nil A) : ∗
...
. . . ⊢ . . . : ∗
...
A: ∗ ⊢ Π(P : List A → ∗)(l : List A) . . . : ∗
⊢ Π(A: ∗)(P : List A → ∗)(l : List A). P (nil A) → Π(a : A)(r : List A). P r → P (cons A y r) → P l : ∗
Cody Roux (Draper Labs) PTSes February 17, 2015 30 / 38

31. Other Calculi
Here are a few other examples:
Name Sorts Axioms Rules
STLC(1 base type) ι, ∗ (ι, ∗) (∗, ∗, ∗)
STLC ∗, (∗, ) (∗, ∗, ∗)
∗ : ∗ ∗ (∗, ∗) (∗, ∗, ∗)
System F ∗, (∗, ) (∗, ∗, ∗), ( , ∗, ∗)
CC ∗, (∗, ) (∗, ∗, ∗), ( , ∗, ∗),
(∗, , ), ( , , )
U−
∗, , △ (∗, ), (∗, ∗, ∗), ( , ∗, ∗),
( , △) ( , , ), (△, , )
CCω
∗, i , (∗, i ), (∗, ∗, ∗), ( i , ∗, ∗),
(core of Coq) i ∈ N ( i , j ), i < j ( i , j , k), k ≥ max(i, j)
Cody Roux (Draper Labs) PTSes February 17, 2015 31 / 38

32. Normalization
A PTS is normalizing ⇔ Γ ⊢ t : T ⇒ t has a β-normal form.
Normalization is a central property:
1 It ensures decidability of type-checking
2 It implies consistency of the system as a logic
Cody Roux (Draper Labs) PTSes February 17, 2015 32 / 38

33. Normalization
Normalization is hard to predict:
Name Axioms Rules Norm.
STLC(1 base type) (ι, ∗) (∗, ∗, ∗) Yes
STLC (∗, ) (∗, ∗, ∗) Yes
∗ : ∗ (∗, ∗) (∗, ∗, ∗) No
System F (∗, ) (∗, ∗, ∗), ( , ∗, ∗) Yes
CC (∗, ) (∗, ∗, ∗), ( , ∗, ∗), Yes
(∗, , ), ( , , )
U−
(∗, ), (∗, ∗, ∗), ( , ∗, ∗), No
( , △) ( , , ), (△, , )
CCω
(∗, i ), (∗, ∗, ∗), ( i , ∗, ∗), Yes
(core of Coq) ( i , j ), i < j ( i , j , k), k ≥ max(i, j)
Cody Roux (Draper Labs) PTSes February 17, 2015 33 / 38

34. Other Features
PTSes can capture things like predicative polymorphism:
Only instantiate ∀s with monomorphic types
∀X.X → X → N → N yes
∀X.X → X → (∀Y .Y → Y ) → (∀Y .Y → Y ) no
Sorts: ∗, ˆ∗,
Axioms: ∗ : , ˆ∗ :
Rules: STLC + {( , ∗, ˆ∗), ( , ˆ∗, ˆ∗)}
Cody Roux (Draper Labs) PTSes February 17, 2015 34 / 38

35. Other Features
We can seperate type-level data and program-level data
Sorts: ∗t, ∗p, t, p
Axioms: ∗t : t, ∗p : p
Rules:
{(∗t, ∗t, ∗t ), (∗p, ∗p, ∗p), (∗t, p, p)}
Nt lives in ∗t, Np lives in ∗p
Similar to GADTs!
Cody Roux (Draper Labs) PTSes February 17, 2015 35 / 38

36. More about U−
Remember U−
:
R = {(∗, ∗, ∗), ( , ∗, ∗), ( , , ), (△, , )}
This corresponds to Kind Polymorphism!
But...
It is inconsistent!
U−
⊢ t : ∀X. X
This is (maybe) bad news for constraint kinds!
Cody Roux (Draper Labs) PTSes February 17, 2015 36 / 38

37. Conclusion
Pure Type Systems are functional languages with simple syntax
They can explain many aspects of the Haskell Type System.
Pure Type Systems give fine grained ways of extending the typing
rules.
The meta-theory can be studied in a single generic framework.
There are still hard theory questions about PTS.
Cody Roux (Draper Labs) PTSes February 17, 2015 37 / 38

38. The End
Cody Roux (Draper Labs) PTSes February 17, 2015 38 / 38