Fonctions universelles

On pourrait très bien continuer à exploiter la proposition1.5.5, mais on obtient une forme un peu plus simple pour les fonctions calculables avec une démonstration alternative des résultats précédents qui fait intervenir le code de la suite des états de la machine, plutôt que le temps de calcul qui est la longueur de cette suite. C’est l’objet de la section suivante.

2.2.1 Forme normale de Kleene.

Proposition 2.2.1 Pour chaque entier n≥1il existe un prédicat récursif primitif noté Tⁿ et une fonc-tion récursive primitive U :N→Ntels que pour toute machine de code m calculant une fonction à n arguments f :

1. ∃s Tⁿ[m,x₁, . . . ,x_n,s]⇔f(x₁, . . . ,x_n)↓ 2. Tⁿ[m,x₁, . . . ,x_n,s]⇒U(s)=f(x₁, . . . ,x_n) 3. ¡

Tⁿ[m,x₁, . . . ,x_n,s]etTⁿ[m,x₁, . . . ,x_n,s⁰]¢

⇒s=s⁰

Démonstration. L’idée est quesdésigne le code (en commençant par la fin) d’une suite d’états correcte pourm, soit [e_n; . . . ;e₀]. On commence par définir un prédicatP_n qui indique que la suite d’états est bien correcte (sans que le calcul soit forcément fini), pour une machine de codemavecx₁, . . . ,x_n en entrées. Le prédicatP_nest défini par sa fonction caractéristiqueg_n:

g_n(m,x₁, . . . ,x_n, [])=1

g_n(m,x₁, . . . ,x_n, [e])=χ=(initn(m,x₁, . . . ,x_n),e)

g_n(m,x₁, . . . ,x_n,e::s)=g_n(m,x₁, . . . ,x_n,s)·χ=(tr(m, hd(s)),e)

la fonctiong_n est définie par récurrence structurelle sur les listes, à partir de fonctions récursives pri-mitives. on a vu qu’alorsg_nest récursive primitive. Le prédicatP_nest donc récursif primitif. On définit ensuite

T⁰ⁿ[m,x1, . . . ,xn,s]≡Pn(m,x1, . . . ,xn,s]etHalt[m, hd(s)]

Tⁿ[m,x₁, . . . ,x_n,s]≡T⁰ⁿ[m,x₁, . . . ,x_n,s]et_∀s⁰<s¬T⁰ⁿ[m,x₁, . . . ,x_n,s⁰]

Le prédicat récursif primitifT⁰ⁿ ne vérifie a priori que la première condition de la proposition (termi-naison). Le prédicatTⁿ est récursif primitif et vérifie les deux premières conditions : terminaison et fonctionalité poursen sortie.

La fonctionUa besoin d’extraire la valeur deR₀du code du premier état dessoit : U(s)=hd(π²1(hd(s)))

fonction qui est bien récursive primitive.

Corollaire 2.2.2 (forme normale de Kleene) Les prédicats Tⁿet la fonction U sont ceux de la proposi-tion précédente. Pour toute foncproposi-tion partielle calculable f :Nⁿ→N, il existe au moins un entier m tel que :

f(x₁, . . . ,x_n)=U(µs.Tⁿ[m,x₁, . . . ,x_n,s]) . Démonstration. Il suffit de prendre le codemd’une machine qui calculef. Une expression de la fonctionf comme celle donnée dans le corollaire :

f(x1, . . . ,xn)=g(µs.P(x1, . . . ,xn,s))

oùg:N→Nest une fonction récursive primitive etPun prédicat récursif primitif est dite sousforme normale de Kleene.

Exercice 14 En utilisant les prédicatsTⁿet la fonctionU, démontrer la proposition1.2.8 page 17 (clô-ture par « si ... alors ... sinon ... » dans le cas des fonctions partielles calculables).

2.2. Fonctions universelles. (v. provisoire 28 octobre 2021 13: 33) 35

2.2.2 Propriété d’énumération.

Pour chaquen≥1 on définit la fonction d’aritén+1ϕⁿ:

ϕⁿ(m,x₁, . . . ,x_n)=U(µs.Tⁿ[m,x₁, . . . ,x_n,s]) et on note simplementϕpourϕ¹.

Cette fonction partielle calculable permet de calculer toutes les fonctions partielles calculables àn arguments. On dit que c’est unefonction universellepour les fonctions partielles calculables àn argu-ments. On peut réécrire ainsi le corollaire précédent :

Théorème 2.2.3 (Théorème d’énumération) la famille de fonctions(ϕⁿ)n∈N^∗, définie ci-dessus est telle que pour toute fonction partielle calculable f :Nⁿ→Nil existe au moins un entier m tel que :

f(x₁, . . . ,xn)=ϕⁿ(m,x₁, . . . ,xn)

Un tel entiermsera appelé unindice de f (rappelons que c’est essentiellement le code d’une ma-chine qui calculef). On noteraf =ϕⁿmsimest un code def.

En fait chacune des fonctions (ϕⁿ)_n∈N∗est universelle en un sens un peu plus fort. Par exemple, la fonctionϕ=ϕ¹énumère modulo codage toutes les fonctions partielles calculables :

Corollaire 2.2.4 Pour toute fonction partielle calculable f:Nⁿ→N, il existe un entier i tel que : f(x₁, . . . ,xn)=ϕ(i,〈x₁, . . . ,xn〉)

Démonstration. On prend pouriun indice de la fonction :x7→f(πⁿ₁(x), . . . ,πⁿn(x)).

Il est intuitivement clair (voir exercice suivant) qu’une fonction partielle calculable possède une infinité d’indices : on peut toujours ajouter des détours inutiles dans le programme d’une machine. On montrera plus tard que c’est en un certain sens inévitable.

Exercice 15 (Lemme de bourrage)

1. étant donné une machineMàkregistres, construire une machineM⁰, avec autant de registres, qui calcule la même fonction, et dont le programme a un code strictement plus grand que celui deM.

2. Soitn∈N^∗. Montrer qu’il existe une fonction récursive primitiveu:N→Ntelle que ϕⁿ_u(m)=ϕⁿmet pour toutm u(m)>m

(upeut dépendre den) ;

3. Montrer qu’il existe une fonction récursive primitivev:N²→Ntelle quevest strictement crois-sante en sur son second argument et pour tous entiersmetp,ϕⁿ_v(m,p)=ϕⁿm.

Une conséquence immédiate du théorème d’énumération est que la fonction partielleϕⁿ, qui est cal-culable àn+1 arguments, a un indice : le code d’une machine qui la calcule, que l’on appellemachine universelle.

Corollaire 2.2.5 Pour tout n≥1il existe un entier m_ntel que :

ϕⁿ(m,x₁, . . . ,x_n)=ϕⁿ⁺¹(m_n,m,x₁, . . . ,x_n) .

2.2.3 Propriété de paramétrisation.

Une propriété en quelque sorte réciproque de celle que l’on vient d’énoncer, est aussi caractéris-tique des familles de fonctions universelle, la propriété deparamétrisation.

Théorème 2.2.6 (théorèmesⁿ_mou de paramétrisation) Pour tous entiers m,n≥1il existe une fonction totale calculablesⁿ_m:N^m+1→Ntelle que :

ϕ^m+n(i,x₁, . . . ,xm,y₁, . . . ,yn)=ϕ^m(sⁿ_m(i,x₁, . . . ,xm),y₁, . . . ,yn) Pour la famille de fonctions universelle étudiée ici, la fonctionsⁿ_mest récursive primitive.

Si on on revient aux machines, la fonction sⁿ_mpermet donc, à partir du codeid’une machineMàm+n entrées, et dementiersx₁, . . . ,x_m, de calculer le code d’une machineM⁰àn entrées, qui fonctionne commeM, après avoir fixé lesmpremières entrées àx₁, . . . ,x_m.

Démonstration. On va suivre la remarque précédente. Il s’agit d’abord d’indiquer comment construire M⁰, puis on montre que les constructions se codent de façon récursive primitive. Il faut veiller à ce que la fonction calculée soit bien celle cherchée même quand l’indicei= 〈k,l〉n’est pas un « vrai » code de machine (cf. paragraphe1.5.2). La machineM⁰ va avoir les mêmesk registres. On construit son programme à partir de celui deMen 3 étapes.

1. On ajoute en tête de programme des instructions qui essentiellement (c’est-à-dire quand il y a suffisamment de registres) recopient les registres d’entréesR₁, . . .,R_nà partir deR_m+1(registres de travail), et mettent à 0 lesn premiers registres d’entrées). il faut en fait discuter suivant le nombre de registresk. L’opération est donnée,

sik≤mpar la séquence

R_k:=0, . . . ,R₁:=0 sim<k<m+npar la séquence

R_k:=R_k−m, . . . ,R_m+1:=R₁ et sik≥m+npar la séquence

R_m+n:=R_n, . . . ,R_m+1:=R₁. Chacune des instructionsRm+i:=Ri, respectivementRi:=0, s’écrit

l ifR_i=0gotol+4 l+1 R_m+i:=R_m+i+1 l+2 R_i:=R_i−1 l+3 gotol

l ifR_i=0gotol+3 l+1 R_i:=R_i−1 l+2 gotol

avec, par exemple dans le dernier casl=4(n−i). On ajoute 3klignes dans le premier cas, 4(k−m) dans le second cas et 4nlignes dans le dernier.

2. On ajoute ensuite les instructions qui correspondent à : R1:=x1, . . . ,Rm:=xm

chaque opérationR_i:=x_is’écrit (le registreR_iest à 0) : R_i:=R_i+1, . . . ,R_i:=R_i+1

| {z }

x_i

on ajoute doncx₁+ · · · +x_mlignes.

3. On ajoute le programme deM modifié de façon à se comporter de la même façon que pour la machineM, c’est-à-dire que les instructionsgotodoivent pointer sur les numéros de lignes décalées du nombre d’instructions ajouté en tête de programme. Ce nombre est une fonction de (k,x₁, . . . ,x_m) (metnsont des constantes).

Il est à peu près clair qu’à chaque étape correspond une opération récursive primitive sur le code. Ceux qui n’en sont pas convaincus sont invités à le démontrer eux-mêmes, ou, en dernier ressort, à chercher de possibles erreurs dans les détails donnés ci-dessous.