Système T

À l'instar de la récursion primitive ou le lambda-calcul, le Système T est un système formel. Il a été inventé par le logicien Kurt Gödel^[1] pour montrer la cohérence de l'arithmétique de Heyting au moyen de son interprétation Dialectica (en).

Ce système consiste en une extension du lambda-calcul simplement typé avec des entiers naturels et la possibilité de définir des fonctions par récurrence. Le système T est plus expressif que le lambda-calcul simplement typé et que la récursion primitive étant donné qu'il permet de définir la fonction d'Ackermann. En fait, les fonctions définissables dans le système T sont exactement les fonctions prouvablement totales dans l'arithmétique de Peano, ou de façon équivalente, dans l'arithmétique de Heyting.

Le principe est simple : on garde les schémas récursifs primitifs :

$f(0,{\vec {y}})=g({\vec {y}})$

$f(Succ(x),{\vec {y}})=h(x,f(x,{\vec {y}}),{\vec {y}})$

La différence majeure est que l'on autorise les paramètres ${\vec {y}}$ à être des fonctions. Par rapport à la récursion primitive, il est alors possible, par exemple, de faire une récurrence sur plusieurs paramètres.

Formalisme

Le formalisme se base sur celui du lambda-calcul simplement typé. On y ajoute un type représentant les entiers naturels, ${\mathsf {Nat}}$ , ainsi qu'un type représentant les booléens, ${\mathsf {Bool}}$ ^[2].

Pour les booléens, on considère deux constantes, $\operatorname {T}$ (Vrai, en anglais : True) et $\operatorname {F}$ (Faux, en anglais : False), ainsi qu'une construction $\operatorname {if} _{A}u~v~w$ avec $u$ un booléen et $v$ et $w$ de même type $A$ . Cette opération représente une instruction conditionnelle : si $u$ est vrai, on renvoie $v$ , sinon $w$ . Cela se traduit par les règles $\operatorname {if} _{A}\operatorname {T} v~w\to v$ et $\operatorname {if} _{A}\operatorname {F} v~w\to w$ .

$(\operatorname {T} )\;{\frac {}{\Gamma \vdash \operatorname {T} :{\mathsf {Bool}}}}$	$(\operatorname {F} )\;{\frac {}{\Gamma \vdash \operatorname {F} :{\mathsf {Bool}}}}$
$(\operatorname {if} )\;{\frac {\Gamma \vdash u:{\mathsf {Bool}}\quad \Gamma \vdash v:A\quad \Gamma \vdash w:A}{\Gamma \vdash \operatorname {if} _{A}u~v~w:A}}$

Les entiers sont construits soit à partir de la constante $0$ , soit comme le successeur $\operatorname {S} u$ d'un autre entier $u$ , qui représente $u+1$ . Ainsi, si $n$ est un entier naturel usuel, il sera représenté dans le système T par le terme $\operatorname {S} ^{n}0=\overbrace {\operatorname {S} \cdots \operatorname {S} } ^{n}~0$ , qui consiste en $n$ applications successives de $\operatorname {S}$ au terme $0$ .

Si $u$ est un entier, $v$ a pour type $A$ et $w$ est une fonction qui prend un entier et un élément de type $A$ et renvoie un élément de type $A$ , $\operatorname {rec} _{A}u~v~w$ est de type $A$ . L'idée derrière $\operatorname {rec}$ est que le terme $\lambda u^{\mathsf {Nat}}.\operatorname {rec} _{A}u~v~w$ représente la fonction $f$ définie par récurrence avec $f(0)=u$ et $f(n+1)=w(n,f(n))$ : on considère donc les règles de réduction $\operatorname {rec} _{A}0~v~w\to v$ et $\operatorname {rec} _{A}(\operatorname {S} u)~v~w\to wu(\operatorname {rec} _{A}u~v~w)$ .

$(0)\;{\frac {}{\Gamma \vdash 0:{\mathsf {Nat}}}}$	$(\operatorname {S} )\;{\frac {\Gamma \vdash u:{\mathsf {Nat}}}{\Gamma \vdash \operatorname {S} ~u:{\mathsf {Nat}}}}$
$(\operatorname {rec} )\;{\frac {\Gamma \vdash u:{\mathsf {Nat}}\quad \Gamma \vdash v:A\quad \Gamma \vdash w:{\mathsf {Nat}}\to A\to A}{\Gamma \vdash \operatorname {rec} _{A}u~v~w:A}}$

On peut noter que la réduction est confluente, préserve les types et est fortement normalisante^[3]. On peut de plus montrer que les termes clos — c'est-à-dire sans variable libre — de type ${\mathsf {Nat}}$ sont tous de la forme $\operatorname {S} ^{n}0$ pour un certain entier naturel $n$ , et les termes clos de type ${\mathsf {Bool}}$ sont $\operatorname {T}$ et $\operatorname {F}$ ^[4].

Exemples

Le prédécesseur

La fonction prédécesseur vérifie les équations suivantes^[5] :

${\mathsf {Pred}}~0=0$ ;
${\mathsf {Pred}}~(\operatorname {S} n)=n$ .

On peut donc l'écrire sous forme de terme comme :

{\mathsf {Pred}}=\lambda n^{\mathsf {Nat}}.\operatorname {rec} _{\mathsf {Nat}}n~0~\left(\lambda n'^{\mathsf {Nat}}.\lambda r^{\mathsf {Nat}}.n'\right).

Un minimum efficace

En récursion primitive, on ne peut pas faire une fonction qui retourne le minimum de deux entiers en temps de calcul minimum de ces deux entiers^[6]. C'est très contraignant si on calcule, par exemple, le minimum de 2 et 1 000 000. Comme le système T permet les récursions sur plusieurs paramètres, on peut trouver un algorithme plus efficace.

Intuitivement, la fonction minimum vérifie les équations suivantes :

${\mathsf {Min}}~0~0=0$ ;
${\mathsf {Min}}~(\operatorname {S} 0)~0=0$ ;
${\mathsf {Min}}~(\operatorname {S} m)~(\operatorname {S} n)=\operatorname {S} ({\mathsf {Min}}~m~n)$ .

En transformant un peu on obtient des équations utilisant le schéma souhaité :

${\mathsf {Min}}~0=\lambda m^{\mathsf {Nat}}.~0$ ;
${\mathsf {Min}}~(\operatorname {S} m)=\lambda n^{\mathsf {Nat}}.{\mathsf {Min'}}({\mathsf {Min}}~m)~n$ ;
${\mathsf {Min'}}f~0=0$ ;
${\mathsf {Min'}}f~(\operatorname {S} ~n)=\operatorname {S} (f~n)$ .

Le terme voulu est :

{\mathsf {Min}}=\lambda m^{\mathsf {Nat}}.\operatorname {rec} _{{\mathsf {Nat}}\to {\mathsf {Nat}}}m~(\lambda n^{\mathsf {Nat}}.~0)~\left(\lambda m'^{\mathsf {Nat}}.\lambda f^{{\mathsf {Nat}}\to {\mathsf {Nat}}}.\lambda n^{\mathsf {Nat}}.\operatorname {rec} _{\mathsf {Nat}}n~0~\left(\lambda n'^{\mathsf {Na}}.\lambda r^{\mathsf {Nat}}.\operatorname {S} (f~n')\right)\right).

De la même manière, on peut obtenir facilement un programme optimisé pour l'addition et la soustraction.

La fonction d'Ackermann

La fonction d'Ackermann est définie ainsi :

${\mathsf {Ack}}(m,n)={\begin{cases}n+1&{\mbox{si }}m=0\\{\mathsf {Ack}}(m-1,1)&{\mbox{si }}m>0{\mbox{ et }}n=0\\{\mathsf {Ack}}(m-1,{\mathsf {Ack}}(m,n-1))&{\mbox{si }}m>0{\mbox{ et }}n>0.\end{cases}}$

On remarque que cette définition n'est pas une instance valide du schéma de récurrence primitive récursive : en effet, la récurrence primitive n'autorise pas à définir par récurrence une fonction qui renvoie autre chose qu'un entier (en l'occurence, il faudrait pouvoir renvoyer une fonction), mais ce n'est pas une limitation de système T. En fait, la fonction d'Ackermann n'est pas une fonction primitive récursive^[7].

Ainsi, en modifiant un peu la définition, on obtient la forme désirée :

${\mathsf {Ack}}~0=\lambda n^{\mathsf {Nat}}.\operatorname {S} n$ ;
${\mathsf {Ack}}~(\operatorname {S} m)=\lambda n^{\mathsf {Nat}}.{\mathsf {Ack'}}~({\mathsf {Ack}}~m)~n$ ;
${\mathsf {Ack'}}~f~0=f(\operatorname {S} 0)$ ;
${\mathsf {Ack'}}~f~(\operatorname {S} n)=f({\mathsf {Ack'}}~f~n)$ .