We describe a type system for the linear-algebraic lambda-calculus. The type system accounts for the part of the language emulating linear operators and vectors, i.e. it is able to statically describe the linear combinations of terms resulting from the reduction of programs. This gives rise to an original type theory where types, in the same way as terms, can be superposed into linear combinations. We show that the resulting typed lambda-calculus is strongly normalizing and features a weak subject-reduction.

1. A type system for the vectorial aspects of the
linear-algebraic lambda-calculus
Pablo Arrighi1,2 Alejandro Díaz-Caro1 Benoît Valiron3,4
1
Université de Grenoble, LIG, France
2
École Normale Supérieure de Lyon, LIP, France
3
Université de Paris-Nord, LIPN, France
4
University of Pennsylvania, USA
7th DCM • July 3, 2011 • Zurich, Switzerland

2. M, N ::= x | λx.M | (M)N | M + N | α.M | 0
Beta reduction:
(λx.M)N → M[x := N]
“Algebraic” reductions:
α.M + β.M → (α + β).M,
(M)(N1 + N2 ) → (M)N1 + (M)N2 ,
...
...
...
(oriented version of the axioms of vectorial spaces)
Two origins:
Differential λ-calculus: capturing linearity à la Linear Logic
→ Removing the differential operator : Algebraic λ-calculus (λalg ) [Vaux’09]
Quantum computing: superposition of programs
→ Linearity as in algebra: Linear-algebraic λ-calculus (λlin )
[Arrighi,Dowek’08]
2 / 15

3. M, N ::= x | λx.M | (M)N | M + N | α.M | 0
Beta reduction:
(λx.M)N → M[x := N]
“Algebraic” reductions:
α.M + β.M → (α + β).M,
(M)(N1 + N2 ) → (M)N1 + (M)N2 ,
...
...
...
(oriented version of the axioms of vectorial spaces)
λalg λlin
Origin Linear Logic Quantum computing
Strategy Call-by-name Call-by-value
Algebraic part Equalities Rewrite system
2 / 15

4. An infinite dimensional vectorial space of values
B = {Mi : Mi is a variable or abstraction }
Set of values ::= Span(B)
(Now we should call λlin ’s strategy: “call-by-base”)
3 / 15

5. Why would it be interesting?
Several theories using the concept of linear-combination of terms
quantum, probabilistic, non-deterministic models, . . .
“Why would vector spaces be an interesting theory?”
Many applications and moreover, interesting by itself!
Aim of the current work:
A type system capturing the “vectorial” structure of terms
. . . to check for probability distributions
. . . or “quantumness” of the term
. . . or whatever application needing the structure of the vector
in normal form
. . . a Curry-Howard approach to defining
Fuzzy/Quantum/Probabilistic logics from
Fuzzy/Quantum/Probabilistic programming languages.
4 / 15

6. The Scalar Type System [Arrighi,Díaz-Caro’09]
A polymorphic type system tracking scalars:
Γ M:T Barycentric restrictions
Γ α.M : α.T Characterises the “amount” of terms
The Additive Type System [Díaz-Caro,Petit’10]
A polymorphic type system with sums:
Γ M:T Γ N:R Sums ∼ Assoc., comm. pairs
Γ M +N :T +R distributive w.r.t. application
Can we combine them?
5 / 15

7. The Vectorial Type System
Types:
T , R, S := U | T + R | α.T
U, V , W := X | U → T | ∀X .U
(U, V , W reflect the basis terms)
Equivalences:
1.T ≡ T
α.(β.T ) ≡ (α × β).T
α.T + α.R ≡ α.(T + R)
α.T + β.T ≡ (α + β).T
T +R ≡ R +T
T + (R + S) ≡ (T + R) + S
(reflect the vectorial spaces axioms)
6 / 15

8. The factorisation rule problem
Γ M:T Γ M:T
===========
===========
Γ α.M + β.M : α.T + β.T
However, α.M + β.M → (α + β).M
In general α.T + β.T = (α + β).T = (α + β).T
(and since we are working in System F, there is no principal types neither)
7 / 15

9. Several possible solutions:
Remove factorisation rule (Done. SR and SN both work)
+ in scalars not used anymore. Scalars ⇒ Monoid
It works!... but it is no so expressive (“vectorial” structure lost)
8 / 15

10. Several possible solutions:
Remove factorisation rule (Done. SR and SN both work)
+ in scalars not used anymore. Scalars ⇒ Monoid
It works!... but it is no so expressive (“vectorial” structure lost)
Add several typing rules to allow typing (α + β).M with α.T + β.T
As soon as we add one, we have to add many to make it work
Too complex and inelegant (subject reduction by axiom)
8 / 15

11. Several possible solutions:
Remove factorisation rule (Done. SR and SN both work)
+ in scalars not used anymore. Scalars ⇒ Monoid
It works!... but it is no so expressive (“vectorial” structure lost)
Add several typing rules to allow typing (α + β).M with α.T + β.T
As soon as we add one, we have to add many to make it work
Too complex and inelegant (subject reduction by axiom)
Church style
Seems to be the natural solution
Big complexity with polymorphism and distributivity
8 / 15

12. Several possible solutions:
Remove factorisation rule (Done. SR and SN both work)
+ in scalars not used anymore. Scalars ⇒ Monoid
It works!... but it is no so expressive (“vectorial” structure lost)
Add several typing rules to allow typing (α + β).M with α.T + β.T
As soon as we add one, we have to add many to make it work
Too complex and inelegant (subject reduction by axiom)
Church style
Seems to be the natural solution
Big complexity with polymorphism and distributivity
Weak subject reduction (this work)
What is the best we can get in Curry style?
8 / 15

13. Typing rules
Γ M:T Γ M:T
ax 0I αI
Γ, x : U x :U Γ 0 : 0.T Γ α.M : α.T
n m
Γ M: αi .∀X .(U → Ti ) Γ N: βi .Vj ∀Vj ,∃Wj /U[Wj /X ]=Vj
i=1 j=1
n m
→E
Γ (M)N : αi × βi .Ti [Wj /X ]
i=1 j=1
Γ, x : U M:T Γ M:T Γ N:R
→I +I
Γ λx.M : U → T Γ M +N :T +R
Γ M:U X ∈FV (Γ)
/ Γ M : ∀X .U
∀I ∀E
Γ M : ∀X .U Γ M : U[V /X ]
9 / 15

14. (α + β).T α.T + β.T if ∃M / Γ M : T and Γ M:T
(and its contextual closure)
10 / 15

15. (α + β).T α.T + β.T if ∃M / Γ M : T and Γ M:T
(and its contextual closure)
Theorem (A weak subject reduction)
If Γ M : T and M →R N, then
if R is not a factorisation rule: Γ N:T
if R is a factorisation rule: ∃S T /Γ N:S
10 / 15

16. (α + β).T α.T + β.T if ∃M / Γ M : T and Γ M:T
(and its contextual closure)
Theorem (A weak subject reduction)
If Γ M : T and M →R N, then
if R is not a factorisation rule: Γ N:T
if R is a factorisation rule: ∃S T /Γ N:S
How weak?
Let M → N,
Subject reduction
Γ M:T ⇒Γ N:T
Subtyping
Γ M:T ⇒Γ N : S, but S ≤ T , so Γ N:T
Our theorem
Γ M:T ⇒Γ N : S, and S T
10 / 15

17. Confluence and Strong normalisation
In the original untyped setting: “confluence by restrictions”:
YB = (λx.(B + (x)x))λx.(B + (x)x)
YB → B + YB → B + B + YB → . . .
11 / 15

18. Confluence and Strong normalisation
In the original untyped setting: “confluence by restrictions”:
YB = (λx.(B + (x)x))λx.(B + (x)x)
YB → B + YB → B + B + YB → . . .
YB + (−1).YB −→ (1 − 1).YB −→∗ 0
↓ Solution in the untyped setting:
B + YB + (−1).YB α.M + β.M → (α + β).M
↓∗ only if M is closed-normal
B
11 / 15

19. Confluence and Strong normalisation
In the original untyped setting: “confluence by restrictions”:
YB = (λx.(B + (x)x))λx.(B + (x)x)
YB → B + YB → B + B + YB → . . .
YB + (−1).YB −→ (1 − 1).YB −→∗ 0
↓ Solution in the untyped setting:
B + YB + (−1).YB α.M + β.M → (α + β).M
↓∗ only if M is closed-normal
B
In the typed setting: Strong normalisation solves the problem
11 / 15

20. Theorem (Strong normalisation)
Γ M : T ⇒ M strongly normalising.
Proof.
Reducibility candidates method.
Main difficulty: Show that
{Mi }i strongly normalizing ⇒ αi .Mi strongly normalizing
i
Done by using a measurement on terms decreasing on algebraic
rewrites.
12 / 15

21. Theorem (Confluence)
M →∗ N1 N1 →∗ L
∀M / Γ M:T ∗ ⇒ ∃L such that
M → N2 N2 →∗ L
Proof.
M → N1 N1 →∗ L
1) local confluence: ⇒ ∃L such that
M → N2 N2 →∗ L
Algebraic fragment: Coq proof
Beta-reduction: Straightforward extension
Commutation: Induction
2) Local confluence + Strong normalisation ⇒ Confluence [TeReSe’03]
13 / 15

22. Expressing matrices and vectors
true = λx.λy .x
Two base vectors:
false = λx.λy .y
14 / 15

23. Expressing matrices and vectors
true = λx.λy .x
Two base vectors:
false = λx.λy .y
T = ∀XY .X → Y → X
Their types:
F = ∀XY .X → Y → Y
α.true + β.false : α.T + β.F
14 / 15

24. Expressing matrices and vectors
true = λx.λy .x
Two base vectors:
false = λx.λy .y
T = ∀XY .X → Y → X
Their types:
F = ∀XY .X → Y → Y
α.true + β.false : α.T + β.F
(U)true = a.true + b.false
Linear map U s.t.
(U)false = c.true + d .false
14 / 15

25. Expressing matrices and vectors
true = λx.λy .x
Two base vectors:
false = λx.λy .y
T = ∀XY .X → Y → X
Their types:
F = ∀XY .X → Y → Y
α.true + β.false : α.T + β.F
(U)true = a.true + b.false
Linear map U s.t.
(U)false = c.true + d .false
U := λx.{((x)[a.true + b.false])[c.true + d .false]}
with [M] := λz.M
{M} := (M)_
{[M]}→ M
U : ∀X .((I → (a.T + b.F)) → (I → (c.T + d .F)) → X ) → X
14 / 15

26. Contributions
Scalar ∪ Additive (“AC, distributive pairs”)
⇒ linear-combination of types
The typing gives the information of
“how much the scalars sums” in the normal form
Weak SR
⇒ Church style captures better the vectorial structure
Strong normalisation
⇒ Confluence without restrictions
Representation of matrices and vectors
15 / 15