Système F stratifié

On appelle Système F stratifié le CTS défini par la spécification suivante : SSFα = {⋆i, i|i < α}

ASFα = {(⋆i, _j)|i < j < α}

RSFα = {(⋆_i, ⋆_j, ⋆_k)|i, j ≤ k < α} ∪ {(_i, ⋆_j, ⋆_k)|0 < i, j ≤ k < α} C_SFα = {(⋆_i, ⋆_j)|i < j < α} ∪ {(_i, _j)|0 < i < j < α}

Tout comme λ⋆_α, le système SFα admet une présentation plus succincte équivalente : S_SFα′ = SSFα

A_SFα′ = {(⋆i, i+1)|i + 1 < α}

R_SFα′ = {(⋆_i, ⋆_i, ⋆_i)|i < α} ∪ {(_i, ⋆_i, ⋆_i)|0 < i < α} C_SFα′ = C_SFα

et on peut prouver que SFα′ est le plus petit sous-CTS P de SFα tel que P = SFα. Ce système se plonge naturellement dans Système F : la fonction

ψ : S_SFα −→ SF

⋆i 7→ ⋆

_i 7→ 

est trivialement un morphisme de SFα dans système F. Il peut être vu comme la version “prédicative” de système F, puisqu’il a été obtenu en stratifiant la sorte des types. On peut par ailleurs prouver que tous les WCTS prédicatifs qui se plongent dans F se plongent dans SFα pour un certain α :

1.3.26 Lemme

Soit P un WCTS prédicatif tel que P ֒→ϕF, alors il existe un morphisme χ tel que P ֒→χSF^Rang(P) et ϕ = ψ ◦ χ.

Démonstration Soit χ la fonction définie par :

χ : SP −→ S_SFRang(P)

s 7→

(

⋆_Rang(s) si ϕ(s) = ⋆ _Rang(s) si ϕ(s) =  Posons α = Rang(P) et montrons que P ֒→χSF^α :

– Soit (s, r) ∈ AP, on doit montrer que (χ(s), χ(r)) ∈ A_SFα. Or comme ϕ est un morphisme, on a (ϕ(s), ϕ(r)) ∈ A_F et donc (ϕ(s), ϕ(r)) = (⋆, ). On en déduit donc que (χ(s), χ(r)) = (⋆_Rang(s), _Rang(r)). Or par définition de <P, on a s <P r et donc d’après le lemme1.3.12, on en déduit Rang(s) < Rang(r). On a donc bien (⋆_Rang(s), _Rang(r)) ∈ A_SFα.

– Soit (s₁, s₂, s₃) ∈ R_P, on doit montrer que (χ(s₁), χ(s₂), χ(s₃)) ∈ R_SFα. Or comme ϕ est un morphisme, on a (ϕ(s1), ϕ(s2), ϕ(s3)) ∈ RF. Deux cas sont alors possibles :

1. Soit (ϕ(s1), ϕ(s2), ϕ(s3)) = (⋆, ⋆, ⋆) et dans ce cas on a :

2. Soit (ϕ(s1), ϕ(s2), ϕ(s3)) = (, ⋆, ⋆) et dans ce cas on a :

(χ(s₁), χ(s₂), χ(s₃)) = (_Rang(s1), ⋆_Rang(s2), ⋆_Rang(s3))

Donc pour prouver (χ(s₁), χ(s₂), χ(s₃)) ∈ R_SFα il suffit de montrer que Rang(s₁) ≤ Rang(s₃) et Rang(s2) ≤ Rang(s3). Or c’est exactement le lemme1.3.14.

– Soit (s, r) ∈ C_P, on doit montrer que χ(s) 4_SFα χ(r). Or comme ϕ est un morphisme et comme CF = ∅, on a ϕ(s) = ϕ(r). Donc il suffit de montrer que Rang(s) ≤ Rang(r). On utilise pour ça

le lemme1.3.13. _,

Ce système a été introduit par [Sta81] afin de contourner l’imprédicativité de Système F : En effet, contrairement à système F, l’absence d’imprédicativité permet de donner des modèles ensemblistes simples.

Le système SFα vérifie les propriétés suivantes : 1.3.27 Lemme 1. SF^α |= CTS, 2. SF^α |= SR_β, 3. SF^α |= MINLOC, 4. SF^α |= PRINCIPAL, 5. SF^α |= UPSTABLE, 6. SF^α |= STRENGTHENING, 7. SF^α |= PREDICATIVE, 8. SF^ω |= DECIDABLE,

Démonstration 1. La relation C_SFα est une relation transitive. 2. C’est une conséquence directe du lemme1.1.42.

3. La vérification est immédiate.

4. La relation CSFα est un ordre strict bien-fondé. 5. La vérification deUPSTABLE est immédiate. 6. C’est une conséquence directe du lemme1.2.42.

7. La relation <SFα est égale à la la relation {(⋆i, ⋆j), (⋆i, j)|i < j < α} que l’on peut représenter par :

⋆_{0 0} ⋆_{1 1} ⋆_{2 2} ⋆_{3 3}

On a ⋆i <_SFα _j car ASFα ⊆ <SFα et ⋆i <_SFα ⋆_j car (j, ⋆_j, ⋆_j) ∈ RSFα et ⋆i <_SFα _j. 8. Tous les CTS prédicatifs sont fortement normalisables (théorème 1.3.23) et on implémente

faci-lement les tests d’appartenance aux paramètres en comparant des entiers. _, Ce CTS ne vérifie néanmoins pas la conditionFULLet donc l’algorithme infer de la sous-section1.2.10

ne peut pas être utilisé directement pour résoudre le problème de l’inférence du type principal.

Or le fait que SFω ne soit pas un CTS dépendant (c’est-à-dire nous n’avons pas la règle de la forme (⋆i, _j, k)), nous permet de montrer facilement par inversion (lemme1.1.32) qu’on ne trouve jamais de redex dans les types. On en déduit alors que l’ensemble des habitants de ⋆i est décrit par :

InhabΓ(⋆i) = {α|α : ⋆j ∈ Γ ∧ j ≤ i }

∪ {A → B|A ∈ InhabΓ(⋆i) ∧ B ∈ InhabΓ, :A(⋆i)} ∪ {∀α : ⋆j.A|A ∈ Inhab_Γ,α:⋆j(⋆_i) ∧ j < i}

et donc que l’appartenance à Inhab_Γ(⋆i) est décidable : il suffit simplement de vérifier récursivement que le terme a la bonne forme. De la même façon, on se convainc que l’appartenance à ensemble

S

i<ωInhabΓ(⋆i) est décidable.

On en déduit alors sans difficulté que l’algorithme suivant est correct et complet pour le problème de l’inférence du type principal dans SFω.

infer_Γ(x) =

(

A si x : A ∈ Γ

sinon inferΓ(⋆i) = i+1 infer_Γ(_i) = inferΓ(λx : A.M) =             

∀x : A. infer_Γ,x:A(M) s’il existe i ∈ N et j ∈ N tels que A ∈ Inhab_Γ(⋆_i) ∨ A = ⋆_i inferΓ,x:A(M) ∈ InhabΓ(⋆j)

sinon infer_Γ(M N) =                  B[N/x] si infer_Γ(M) = ∀x : A.B,

et s’il existe i ∈ N tel que inferΓ(N) = ⋆i B si inferΓ(M) = ∀x : A.B

et s’il existe i ∈ N tel que infer_Γ(N) ∈ Inhab_Γ(⋆_i)

sinon inferΓ(∀x : A.B) =       

⋆_max(i,j) si si= infer_Γ(A) avec s ∈ {⋆, } et ⋆_j = infer_Γ,x:A(B)

sinon

Cet algorithme traite les abstractions et les applications en distinguant deux cas : les abstrac-tions/applications de type (dans le cas où le domaine de l’abstraction est égal à ⋆i ou dans le cas où l’argument de l’application appartient à Inhab_Γ(⋆i)).

Programmation. On peut représenter les entiers en suivant l’encodage habituel des entiers de Church paramétré par le niveau du type. Si n est un entier, on notera ni l’expression

λα : ⋆_i, f : α → α, x : α.

n fois

z }| {

f (f · · · (f x) · · · )

et on notera nat_i son type principal, c’est-à-dire :

nat_i = ∀α : ⋆i.(α → α) → α → α On a ⊢ nat_i: ⋆_i+1et, pour tout entier n, la règle suivante est admissible :

⊢ nⁱ : nat_i

On peut implémenter la fonction retournant le successeur des entiers : succ_i : nat_i→ nati

succ_i = λn : nat_i, α : ⋆_i, f : α → α, x : α.f (n α (f x)) succ_i nⁱ D n + 1ⁱ

Et on peut itérer cette fonction via l’encodage des entiers pour implémenter l’addition : plus_i : nat_i+1→ nati → nati

plus_i = λn : nati+1.n nat_i succ_i plus_i nⁱ⁺¹mⁱ D n + mⁱ

On note au passage que le niveau du type de l’argument sur lequel on effectue l’itération doit être incrémenté pour que le terme soit bien typé. On peut alors voir les entiers de type nati comme étant des entiers que l’on peut utiliser pour construire par itération d’une fonction des entiers de niveau strictement inférieur à i.

On utilise alors les fonctions coercionj

i pour j < i afin de plonger la représentation d’un entier vers un niveau inférieur :

coercion^j_i : nat_i→ natj

coercion^j_i = λn : nati, α : ⋆j, f : α → α, x : α.n α f x coercion^j_i nⁱ D n^j

On remarque que si on accepte “d’ouvrir la représentation des entiers” (en introduisant à gauche la quantification de type), on peut parvenir à implémenter certaines opérations avec un type plus souple. Comme par exemple pour l’addition :

plus_i : nat_i → nati → nati

plus_i = λn m : nat_i, α : ⋆_i, f : α → α, x : α.n α f (m α f x) plus_i nⁱmⁱ D n + mⁱ

De même pour la multiplication :

mult_i : nat_i→ nati→ nati

mult_i = λn m : nat_i, α : ⋆_i, f : α → α, x : α.n α (m α f ) x mult_i nⁱmⁱ D n × mⁱ

L’implémentation de l’exponentiation est un peu plus difficile, mais l’idée est la même : il faut repousser le plus tard possible l’utilisation de l’abstraction de type.

exp_i : nat_i → nati→ nati exp_i = λn : nat_i, m : nat_i, α : ⋆_i.

m ((α → α) → α → α)

(λk : (α → α) → α → α, f : α → α.n α (k f)) (λf : α → α, x : α.f x)

exp_i nⁱmⁱ D nmi

La fonction qui permet de représenter les tours d’exponentielles de hauteur arbitraire peut être implémentée par le terme ci-dessus de type nati+1→ nati → nati.

tower_i : nat_i+1→ nati→ nati

tower_i = λn : nati+1, m : nat_i.n (nati) (exp_i 2ⁱ) m tower_i nⁱ⁺¹mⁱ D 22..^.mi

(la tour est de hauteur n)

On verra plus tard qu’on atteint ce qui semble être les limites de l’itération dans ce système, puisqu’on montrera qu’elle ne peut pas être implémentée avec un type de la forme nati → nati→ nati.

On peut également utiliser l’encodage standard pour encoder le produit cartésien à l’aide de la quantification du second-ordre. On notera donc σ ×kτ le type ∀γ : ⋆_k.(σ → τ → γ) → γ. On notera que le type du produit doit être indexé par le niveau de la conclusion. On a alors α : ⋆i, β : ⋆j ⊢ α ×_kβ : ⋆_max(k+1,i,j) :

α : ⋆_i, β : ⋆_j ⊢ ⋆k: k+1

Γ ⊢ α : ⋆i Γ ⊢ β : ⋆i Γ ⊢ γ : ⋆k Γ ⊢ (α → β → γ) → γ : ⋆_max(k,i,j) α : ⋆_i, β : ⋆_j ⊢ α ×kβ : ⋆_max(k+1,i,j)

Cette famille de types est alors munie des fonctions de construction et destructions suivantes : proj¹_i : ∀α β : ⋆i.α ×iβ → α

proj¹_i = λα β : ⋆i, c : α ×_iβ.c α (λx : α, y : β.x) proj²_i : ∀α β : ⋆i.α ×_iβ → β

proj²_i = λα β : ⋆i, c : α ×_iβ.c α (λx : α, y : β.y) pair_i : ∀α β : ⋆i.α → β → α ×_iβ

On notera hA, Bii le terme pair_i σ τ A B où σ et τ seront les types principaux de A et B dans le contexte considéré (il peut toujours être inféré). De la même façon, on notera (A)k

i le terme projk i σ τ A quand σ ×_iτ sera le type de A. On montre alors facilement que les dérivations de typage suivantes sont admissibles : Γ ⊢ M : τ Γ ⊢ N : σ ^{Γ ⊢ τ : ⋆}i Γ ⊢ σ : ⋆_i Γ ⊢ hM, Ni_i: τ ×_iσ Γ ⊢ M : τ₁×iτ₂ Γ ⊢ τ₁ : ⋆_i Γ ⊢ τ₂ : ⋆_i Γ ⊢ (M)k i : τk Et on vérifie facilement les règles de réduction suivantes :

(hA₁, A₂i_i)1

i ⊲ A₁ (hA1, A2ii)2

i ⊲ A2

On peut en déduire par une technique standard une implémentation du prédécesseur sur les entiers : pred_i : nat_i+1→ nati

pred_i = λn : nat_i+1, α : ⋆_i, f : α → α, x : α.

 n (α ×_iα) (λc : α ×_iα.hf (c)¹_i, (c)¹_ii) hx, xi^2 i pred_i n + 1ⁱ⁺¹ D ni pred_i 0i+1 D 0i

Et, en suivant la même technique, on peut implémenter l’itérateur “rec” qui nous donne un schéma de récursion général :

rec_i : ∀α.(α → nati→ α) → α → nati+2→ α rec_i = λα : ⋆i, f : α → nat_i→ α, x : α, n : nati+2.



n (α ×_i+1nati)

(λc : α ×i+1nat_i.hf (c)¹_i+1(c)2

i+1, succ_i(c)2 i+1ii+1) hx, 0ⁱii+1^1 i+1 rec_i α f x 0ⁱ⁺² D x rec_i α f x n + 1ⁱ⁺² D n + 1 fois z }| { f (f · · · (f x0i) · · · n − 1i) ni

On peut utiliser ce schéma de récurrence pour implémenter des schémas de produit, de somme et de “tétration” bornés :

sum_i : (nati→ nati) → nati+2→ nati

sum_i = λ(f : nat_i→ nati)(n : nat_i+2). rec_i nat_i(λr n : nat_i. plus_i r (f n))0i n sum_i fⁱnⁱ⁺² D f (0) + · · · + f (n − 1)ⁱ

prod_i : (nati→ nati) → nati+2→ nati

prod_i = λ(f : nat_i→ nat_i)(n : nat_i+2). rec_i nat_i(λr n : nat_i. mult_i r (f n)) 1ⁱn prod_i fⁱnⁱ⁺² D f (0) × · · · × f (n − 1)ⁱ

tret_i : (nat_i→ nat_i) → nat_i+2→ nat_i

tret_i = λ(f : nati→ nati)(n : nati+2). reci nat_i(λr n : nati. exp_i r (f n)) 1ⁱn tret_i fⁱnⁱ⁺² D f (n − 1)(f (n−2)..^{.f (0))}

i

où fⁱ désigne un terme de type nati → nati représentant une fonction numérique f : N −→ N (c’est-à-dire tel que pour tout n, fⁱnⁱDf (n)ⁱ).

On ne peut néanmoins pas utiliser le schéma rec_i pour itérer sur des fonctions qui ne sont pas de la forme α → nati → α. En particulier, on ne peut pas l’utiliser sur la fonction toweri vue plus haut.

Daniel Leivant [Lei91] a prouvé que les fonctions représentables dans ce système sont exactement les fonctions super-élémentaires correspondant au quatrième étage ξ₄ de la hiérarchie de Grzegorczyk (voir [Ros] par exemple). Cet ensemble de fonctions est strictement inclus dans l’ensemble des fonctions primitives récursives qui est lui-même strictement plus petit que l’ensemble des fonctions représen-tables dans système F. En particulier, la fonction d’Ackermann ack, connue pour ne pas être primitive récursive, est représentable dans système F.

Dans le document Réalisabilité et paramétricité dans les systèmes de types purs (Page 99-105)