Types de données dans le système F

Les calculs à la Church usuels (tels que3.1) vérifient la propriétéd’unicité du typage:

pour tout contexte Γ et tout terme t, il existe au plus un type tel queΓ ⊢t:T.

Les systèmesà la Church tels que nous les définissons ne sont en fait pas exactement

équivalents aux systèmes à la Church usuels. En particulier, l’unicité du typage est plus

forte : puisque le type des variables est fixé a priori, le type d’un terme est indépendant

du contexte de typage.

Lemme 3.3.20 (Unicité du typage) Soit ty∈{⇒, 2} ett∈Λ

^C_ty^h

. Alors

Γ ⊢t:T et Γ

^′

⊢t:T

^′

implique T =T

^′

.

Remarque 3.3.21 Pour les systèmes à la Church tels que nous les définissons, si

Γ ⊢ t:T etΓ

^′

⊢t:T alorsΓ etΓ

^′

coïncident sur FV(t). Lorsque le contexte le permet,

nous écrivons t:T au lieu deΓ ⊢t:T.

Les propriétés énoncées par3.3.15et3.3.16sont aussi satisfaites par les systèmesà la

Church.

Lemme 3.3.22 (Préservation du type par réduction) Pour tout ty ∈ {⇒, 2}, si

Γ ⊢

^Ch

ty

t:T ett→

β

ualors Γ ⊢

^Ch

ty

u:T.

Théorème 3.3.23 (Normalisation forte) Pour tout ty∈{⇒, 2}, si Γ ⊢

Ch

ty

t:T alors

t∈ SN

β

.

3.4 Types de données dans le système F

Le système F est suffisamment puissant pour encoder beaucoup de types de données

intéressants. On peut trouver dans [GLT89,Kri90] plus de détails à ce sujet.

Dans cette section, nous voyons comment encoder dans le système F les types de

données présentés à la section 1.1 dans le cadre de la réécriture au premier ordre. Les

explications sur les codages imprédicatifs mélangent volontairement les constructions

algébriques et les λ-termes.

3.4.1 Booléens

Les booléens algébriques sont construits à partir de deux constructeurs true et false.

Le type des booléens est donc le plus petit type T tel qu’on a un élément de T dès lors

qu’on a trueou false. On pose

T

_Bool

=

_def

∀X. X⇒X⇒X .

On représente trueetfalse par les deux habitants les plus simples possibles deT

_Bool

:

Chapitre 3 Réécriture et lambda-calcul

On les élimine avec un termeIter

_Bool

u v ttel queIter

_Bool

u v TrueetIter

_Bool

u v False

simulent les comportements respectifs deiter

_Bool

(u, v,true)et deite

_Bool

(u, v,false).

C’est-à-dire :

Iter

_Bool

u v True →

^∗β

u et Iter

_Bool

u v False →

^∗β

v .

Il doit donc pouvoir être typé comme suit :

u, v:U, b:T

_Bool

⊢

2

Iter

_Bool

u v b:U

Ces deux contraintes sont satisfaites en posantIter

_Bool

u v t=

_def

t u v.

3.4.2 Paires

Les paires algébriques sont construites à partir d’un constructeur binaire(_,_). Donc

le type des paires A×B est le plus petit type T construit à partir d’une fonction dans

A⇒B⇒T. On pose

T

A×B

=

_def

∀X. (A⇒B⇒X)⇒X .

On peut alors représenter(_,_) par

Pair =

_def

λxλyλp.p x y : A⇒B⇒T

A×B

.

Le terme(a, b)correspond à Pair a b, dont la forme_→

wh_β

-normale estλp.p a b.

Les deux projections sont codées à partir d’un itérateur de paires. C’est un terme

Iter

_{_×_}

u ptel que

Iter

_{_×_}

u(Pair a b) →

β

u a b ,

et qui doit donc être typé de la manière suivante :

u:A⇒B⇒U, p:T

_A×B

⊢

2

Iter

_{_×_}

u p:U .

On poseIter

_{_×_}

u p=

_def

p uet on code les projections par

Fst t =

_def

Iter

_{_×_}

True t et Snd t =

_def

Iter

_{_×_}

False t .

Alors on a

Fst(Pair a b) = (λp.p a b)True →

β

(λxy.x)a b →

β

a

Snd(Pair a b) = (λp.p a b)False →

β

(λxy.y)a b →

β

b

ainsi que

a:A, b:B ⊢

2

Fst(Pair a b) : A

a:A, b:B ⊢

2

Snd(Pair a b) : B .

Remarque 3.4.1 Ce typage utilise True et False avec les types A ⇒ B ⇒ A et

A ⇒ B ⇒ B respectivement. Ce n’est pas leur type en tant que booléens. Dans le

système Fà la Church nous ne pourrions pas utiliser ces termes comme sélecteurs dans

les paires : dans ce système True et False sont les termes ΛX.λx

X

y

X

.x etΛX.λx

X

y

X

.y

3.4 Types de données dans le système F

3.4.3 Entiers

Le type des entiers est le plus petit type T construit à partir d’une constante et d’un

symbole de fonction unaire. On pose donc

T

_Nat

=

_def

∀X. X⇒(X⇒X)⇒X .

Les termes

Zero =

_def

λxf.x et Succ =

_def

λn.λxf.f(n x f)

sont de type T

Nat

et représentant respectivement les constructeurs 0 etS(_). Pour tout

n∈N, le terme S

ⁿ

(0) est représenté par le terme Succ

ⁿ

Zero, dont la formeβ-normale

est l’entier de Church λxf.f

ⁿ

xde type T

Nat.

Le système F permet aussi de coder l’itérateuriter(u, v, n) : avec

Iter u v n =

_def

n u v ,

on a

Iter u v Zero = (λxf.x)u v →

β

u

Iter u v(Succ n) = (λxf.f(n x f))u v →

β

v(n u v) = v(Iter u v n)

et

u:U, v:U⇒U, n:T

_Nat

⊢

2

Iter u v n:U .

3.4.4 Vers une extension du lambda-calcul

Nous avons vu comment coder dans leλ-calcul des types de données et leur schémas

d’itération. De plus, ces codages sont typables grâce aux types imprédicatifs du système F.

Cependant, ils souffrent de certaines limitations.

3.4.4.(a) Paires surjectives

Certaines interprétations catégorielles du λ-calcul valident les équations suivantes sur

les paires et les projections : étant donnés deux objets A

₁

,A

₂

, on a deux morphismes

π

i

: A

1

×A

2

→ A

i

(i ∈ {1, 2}) tels que pour tout objet B, pour tout f

i

: A

i

→ B

(i∈{1, 2}) et touth:B→A

₁

×A

₂

,

π

₁

◦(f

₁

, f

₂

) = f

₁

π

₂

◦(f

₁

, f

₂

) = f

₂

(π

₁

◦h, π

₂

◦h) = h .

(3.2)

On a vu en 3.1.4 une définition algébrique des paires et projections dans laquelle les

deux premières équations sont implantées par les règles 7→

π

et la dernière par la règle

7

→

SP

. En 3.4.2, on a vu comment coder le système de réécriture_→

π

dans la syntaxe du

λ-calcul pur et comment typer ce codage grâce aux types imprédicatifs du système F.

Cependant, Barendregt a montré que la règle 7→

SP

n’est pas codable par laβ-conversion

dans le λ-calcul (voir [Bar84]).

Chapitre 3 Réécriture et lambda-calcul

3.4.4.(b) Schéma de récursion

Le récurseur rec présenté à l’exemple 3.1.17.(ii)n’est pas définissable en temps borné

dans le système F : il n’y a pas de terme Rec tel qu’il existe k ∈ N tel que pour tout

termen,

Rec u v 0 →

^kβ

u et Rec u v(Succ n) →

^kβ

v(Rec u v n)n . (3.3)

Cela provient d’un résultat de [Par89] disant qu’il n’y a pas, dans le λ-calcul (donc à

fortioridans le système F), de terme calculant le prédécesseur d’un entier de Church en

temps borné. Or, un tel terme serait définissable s’il existait un termeRecvérifiant (3.3).

En effet :

Rec 0(λ_.λx.x)0 →

^kβ

0 et Rec 0(λ_.λx.x) (Succ n) →

^kβ⁺²

n .

Dans le document Définitions par réécriture dans le lambda-calcul : confluence, réductibilité et typage (Page 77-80)