Lambda-calcul : de la définition à la logique booléenne

Deuxième partie de notre dossier consacré au lambda-calcul ! Après nous avoir présenté l'histoire du Lambda-calcul, Anatolli nous propose cette fois d'en découvrir la définition et les méthodes pour construire des programmes simples équivalents à la machine de Turing.

Dans l’article “Histoire du λ-calcul”, nous avons discuté des événements historiques qui ont amené les mathématiciens à la création de la théorie de la calculabilité. Le lambda-calcul en est une part essentielle. Cependant, nous n’avons pas encore défini ce que signifie le symbole “λ”, ou même le mot “calcul”.

Cette fois, avec cet article, nous souhaitons donner au lecteur le goût du λ-calcul. On présente une définition plutôt complète, puis on montre comment construire un langage de programmation élémentaire mais aussi puissant que la machine de Turing. Ce langage est connu comme le paradigme fonctionnel.

Impérative vs fonctionnelle

Quand on me parle d'”ordinateur”, je pense à la machine de Turing. Réciproquement, si on me parle de “machine de Turing”, j’imagine tout de suit un PC. C’est assez normal puisque la machine de Turing est un concept de langage de programmation (ou d’ordinateur) parmi les plus élémentaires, tellement élémentaire que la notion “ordinateur” et “langage de programmation” n’y sont pas discernables. La machine de Turing est faite d’un ruban contenant des instructions, des données et finalement d’un automate qui lit, efface, réécrit et déplace les données. Tout cela se traduit facilement en un programme impératif — un paradigme implémenté par plus de 9000 langages populaires. Dans ce paradigme, le processus du calcul est décrit en termes d’instructions qui modifient l’état du “calculateur”. Peu importe le langage, les programmes impératifs ont les mêmes caractéristiques :

  • L’état se change par des instructions d’affectation v = E
  • Les instructions sont exécutées consécutivement C1; C2; C3
  • Il existe un mécanisme de branchement if, switch
  • Il existe un mécanisme de boucle while, for

Remarque : Théoriquement, il est suffisant d’avoir une instruction de saut inconditionnel (goto). N’importe quelle boucle est équivalente à une combinaison de if et de goto. Mais, comme l’utilisation de goto est considérée comme une grosse bêtise de développeur, et afin de ne pas enflammer la guerre sainte, restons sur un mécanisme de boucle.

Exemple : calcul impératif d’une factorielle

res = 1;
for i = 1..n:
res = res * i;

On voit clairement que ce programme est impératif car il est composé d’instructions consécutives qui permettent la transition du calculateur de l’état initial à son état final. Une partie de l’état final (variable res) est interprétée comme le résultat du calcul.

Ce programme est très simple, mais seriez-vous capable de proposer une machine de Turing qui calcule une factorielle ? Si vous ne l’avez jamais fait à la main — amusez-vous, c’est un bon exercice de gymnastique mentale.

NB : Si vous préférez lire ou regarder comment les autres réalisent ce type de perversions mathématiques, on ne vous jugera pas…

En tout cas, l’objectif de cet article se trouve en dehors du paradigme impératif — on s’intéresse au paradigme fonctionnel qui présente un programme comme une fonction au lieu d’une liste d’instructions consécutives à exécuter. L’avantage de cette approche est que les effets de bord sont complètement interdits. Par exemple, la factorielle est une fonction qui dépend de l’entrée n et le paradigme garantit que si on appelle deux fois factorielle avec le même n, on obtient le même résultat.
De plus, dans un programme fonctionnel :

  • Il n’existe pas de notion d’état ni de variable
  • Pas de variable — pas d’opération d’affectation
  • Pas de boucle car il n’y a pas de différence entre les itérations
  • L’exécution du programme est une suite de réductions (ou calculs) de son expression jusqu’à l’expression triviale qui ne contient que le résultat
  • L’ordre de calcul n’est pas important car les expressions sont indépendantes

En revanche, le paradigme fonctionnel nous donne :

  • La récursion à la place des boucles.
  • Les fonctions d’ordre supérieur, c’est-à-dire les fonctions qui prennent en entrée et renvoient d’autres fonctions.
  • Le filtrage par motif.

Bien sûr, il est possible de répliquer que l’ensemble de ces propriétés sont présentes dans la plupart des langages modernes. En réalité, les langages modernes sont multi-paradigmes — ils prennent le meilleur de toutes les conceptions. En revanche, le langage machine restent un langage purement impératif. De plus, en programmation fonctionnelle, toutes les fonctions sont pures, elles ne dépendent que de leurs paramètres d’entrée.

Dans la suite, nous allons définir un autre langage primitif — le λ-calcul qui induit la programmation fonctionnelle de la même façon que la machine de Turing induit la programmation impérative. Notre objectif est de réécrire en fonctionnel (et de comprendre !) un programme de calcul de la factorielle d’un nombre entier. Pour cela, nous passerons par toutes les étapes nécessaires :

  • La grammaire du langage (application et abstraction)
  • Les règles d’exécution (\(\alpha\)-equivalence et \(\beta\)-réduction)
  • Le codage des booléens et des nombres (nombres de Church)
  • La récursion à la place de boucles

Dernière avertissement avant de plonger dans le monde des formules ! La construction complète est technique et longue, donc nous allons sauter certains détails sans pitié. Notre objectif est de donner une idée sur la façon dont les primitives de la programmation impérative peuvent être exprimées en termes de \(\lambda\)-calcul. Dans tous les cas, n’utilisez pas cet article comme la seule source si vous avez un examen sur le \(\lambda\)-calcul. Au moins, vous êtes avertis !

  • Si vous avez un examen dans une semaine, prenez n’importe quel livre tiré de la bibliographie en fin d’article
  • Si vous avez un examen demain et que vous ne comprenez rien, lisez au moins ça : Alligator Eggs!

 

Que signifie λ ?

Définition

Un λ-terme ou λ-expression est une expression qui satisfait la grammaire suivante :

  • \(\Lambda \to V\)
  • \(\Lambda \to \Lambda \; \Lambda\)
  • \(\Lambda \to \lambda V. \Lambda\)

où \(V\) est l’ensemble des chaînes sur l’alphabet fixe \(\Sigma \setminus \{“\lambda”, \; “.”, \; “\;”\}\).

La première règle définie des identifiants — variables et fonctions. La deuxième est l’application d’un terme à un autre. La troisième définie une abstraction. Cette grammaire vous semble claire ? Alors vous pouvez passer directement à la β-réduction. Sinon, essayons de rajouter du sens à cet abracadabra.

Quelques explications supplémentaires

1. Identifiant. Initialement, est considéré comme identifiant toute chaîne qui ne contient aucun des trois caractères spéciaux : \(“\lambda”\), \(“.”\) et \(“~”\) (espace). Ainsi, \(x\), \(f\), \(42\), \(hello\) et \(x+5\) sont des identifiants.

2. Application. La notion \(f \; x\) signifie qu’un terme \(f\) est appliqué au terme \(x\). Du point de vue du codeur, on peut dire qu’un algorithme \(f\) est appliqué à l’entrée \(x\). Mais, comme nous construisons un système formel, nous pouvons aller plus loin, par exemple : une auto-application \(f \; f\) est aussi un λ-terme correct.

3. Abstraction. Soit \(\mathbf{M}\) un λ-terme qui contient \(x\) à l’intérieur (on écrit \(\mathbf{M} \equiv \mathbf{M}[x]\)). Dans ce cas, la notion \(\lambda x.M\) signifie une fonction \(x \to \mathbf{M}[x]\) qui mappe \(x\) à \(\mathbf{M}[x]\).

Remarque importante ! Le \(\mathbf{M}\) ou \(\mathbf{M}[x]\) est un pseudonyme pour un λ-terme. Dans la suite de l’article, certains termes seront souvent remplacés par leurs “pseudonymes” pour simplifier les expressions. Ces pseudonymes seront surlignés en gras.

Autre moyen d’aborder l’abstraction — c’est un constructeur de fonction anonyme. Imaginons une fonction \(f(x) := \mathbf{M}[x]\). Dans la notation du λ-calcul, \(f(x)\) correspond à \(\lambda x.\mathbf{M}[x]\). L’avantage d’une telle écriture est de mettre clairement en avant le fait que la fonction dépend de \(x\) mais il n’y a pas d’ambiguïté entre la fonction et sa valeur en \(x\). Finalement, pour une valeur \(f(x=a)\), on écrit :

\(\lambda x. \mathbf{M}[x] \; a\)

Cela est une application : \(\lambda x. \mathbf{M}[x]\) s’applique à \(a\). Par la suite, \([x]\) sera omis et simplement écrit \(\lambda x. \mathbf{M} \; a\). Ainsi, une λ-abstraction est un moyen de créer une fonction anonyme en partant d’une expression \(M\).

Les trois règles ci-dessus sont les seules opérations autorisées pour construire les expressions en λ-calcul. Il est important de répéter que l’univers du λ-calcul ne “sait” rien faire d’autre que construire des phrases intégrant ces trois règles : ni nombre, ni opération arithmétique — rien.

Par exemple, l’identifiant \(x+5\) seul n’a pas le sens d’une “somme”. Il s’agit juste d’une chaîne de caractères, un objet atomique de la théorie. En ce sens, on ne peut pas “calculer” le “résultat” de l’abstraction \(f \; x\) — ce n’est qu’une construction formelle.

β-réduction

Définition. La β-équivalence est définie de manière suivante :

\((\lambda x.\mathbf{M}) \; \mathbf{N} \equiv_\beta \mathbf{M}[x:=\mathbf{N}]\)

 

Une fois de plus, si cette définition vous semble claire, vous pouvez avancer jusqu’à la partie Variables libres et liées.
Sinon, voici une traduction de la langue Klingon.
Soit, dans la formule ci-dessus, \(\mathbf{M} := f \; x \; z \; x\)

Dans ce cas, il est possible de “calculer” l’application en remplaçant toutes les occurrences de \(x\) dans \(\mathbf{M}\) par \(a\) et en enlevant λ :

\(\lambda x. \mathbf{M} \; a = (\lambda x. f \; x \; z \; x) \; a \equiv_\beta f \; a \; z \; a\)

 

Remarque : Ne considérez pas \(f\) comme la fonction qui prend en entrée deux paramètres \(x\) et \(z\). C’est une formule formelle et \(f\), \(x\) ainsi que \(z\) sont trois λ-termes qui ont les mêmes “droits”.

Mais que signifie “calculer” pour un λ-terme ? On dit que les termes \((\lambda x. f \; x \; z \; x) \; a\) et \(f \; a \; z \; a\) sont β-équivalents (pour cela on utilise un symbole “\(\equiv_\beta\)“). L’opération qui vise à supprimer λ en remplaçant un terme par son β-équivalent, s’appelle une β-réduction. En ce sens, “calculer” signifie appliquer les β-réductions pour rendre un λ-terme initial le plus simple possible.

Remarquons aussi que nous avons besoin de parenthèses car nous ne savons pas jusqu’à quel terme s’applique l’abstraction. Pour minimiser le nombre de parenthèses par la suite, nous fixerons les règles suivantes sur les priorités entre les opérations :

  • L’application est gauche-associative, c.-à-d.
    \(\mathbf{F \; X \; Y \; Z := (((F \; X) \; Y) \; Z)}\)
  • L’abstraction est droite-associative, c.-à-d.
    \(\lambda x y z. \mathbf{M} := (\lambda x.(\lambda y.(\lambda z. \mathbf{M})))\)
  • L’abstraction s’applique à tout ce qu’elle arrive à “toucher”, c.-à-d.
    \(\lambda x. \mathbf{M \; N \; K} := \lambda x.(\mathbf{M \; N \; K})\)

α-équivalence : variables libres et liées

Considérons un terme \(\mathbf{M}[x]\) qui contient un identifiant \(x\). Dans le terme \(\lambda x.\mathbf{M}[x]\), la variable \(x\) est liée par une λ-abstraction. Si une variable n’est pas liée, on dit qu’elle est libre. Pour une définition totalement correcte, il manque quelques détails (essayez de la construire par vous-même) mais la notion est assez simple et intuitive.

Exemple : Dans le terme ci-dessous, les variables \(x\) et \(y\) sont liées, \(z\) et \(w\) sont libres :

\((\lambda y. (\lambda x. x \; z) \; y) \; w\)

Maintenant, considerons deux termes \(\mathbf{fx} := \lambda x. f \; x\) et \(\mathbf{fy} := \lambda y. f \; y\). Si on applique chacun des deux termes à un terme quelconque \(a\), on obtient le même résultat :

\(\mathbf{fx} \; a = (\lambda x. f \; x) \; a \equiv_\beta f \; a\)
\(\mathbf{fy} \; a = (\lambda y. f \; y) \; a \equiv_\beta f \; a\)

Cela signifie que les deux termes — qui diffèrent uniquement par leurs variables liées — fonctionnent de la même façon. On dit que ces termes sont α-équivalents :

\(\lambda x. \mathbf{M}[x] \equiv_\alpha \lambda y. \mathbf{M}[y \leftarrow x]\)

On suppose que les termes \(\alpha\)-équivalents sont égaux. C’est la deuxième et derniere règle du λ-calcul.

Un peu de sens

Сette section vise à établir des liens entre la définition formelle du λ-calcul et les lambda-fonctions qu’on peut trouver dans la plupart des langages de programmation.
Ce qu’il faut retenir : ces deux notions sont très différentes ! Les intuitions issues de l’une des deux notions sont souvent des obstacles à la compréhension de la deuxième notion.

Pour ne pas confondre, on utilise le symbole λ uniquement pour le λ-calcul de Church.

En programmation, il est souvent nécessaire de passer en paramètre une fonction : clé pour un tri, opération à appliquer à l’ensemble des éléments d’une collection, etc. Dans ce cas, si la fonction est simple et/ou n’est pas réutilisée, aucun nom ne lui est attribué et on utilise un lambda. En d’autres termes, les deux phrases sont synonymes et la version avec une lambda-fonction est bien plus courte :

  • Soit \(f\) la fonction \(x \to x^2\). Considérons \(A = f(5)\)
  • \(A := (\lambda x.x^2) (5)\)

Dans la théorie du λ-calcul, notre intérêt est différent. On “oublie” qu’une fonction \(f\) est une règle qui mappe \(x\) à \(f(x)\). À la place, on considère une fonction uniquement comme une formule formelle — une phrase construite en respectant une certaine grammaire (celle que nous venons de décrire ci-dessous). Une formule formelle ne doit pas forcement être calculable, par exemple :

  • \(1 + 2 + 3\) est une formule formelle correcte. On peut la calculer et obtenir 6.
  • \(a * b * c\) est également une formule formelle correcte. Si, dans la grammaire de cette formule, \(a, b, c\) correspondent à \(1, 2, 3\) respectivement et \(*\) correspond à une somme, on peut la calculer et obtenir également 6.
  • \(1 + 2 + 3 + 4 + 5 + \ldots\) est aussi une formule formelle correcte. Évidemment, elle ne peut pas être calculée dans le sens commun. Cependant si on change les règles du “jeu”, on peut obtenir 1/12…
  • \(x . \lambda \lambda\) est une formule incorrecte dans la grammaire du λ-calcul. Cette formule ne peut jamais être construite, la définition d’un λ-terme interdit implicitement deux symboles λ de suite.

Tous les λ-termes sont aussi des formules formelles : si, pendant le calcul, on tombe sur une forme \(x \; y \; z\), ou \(x\), \(y\) et \(z\) sont des identifiants simples (c.-à-d. des chaînes de caractères qui ne contiennent ni “λ”, ni “.”, ni espace), il ne faut pas essayer de leur donner du sens : ils ne sont ni des variables, ni des fonctions, ils n’ont pas d’arité non plus — ce sont juste les briques à partir desquelles on construit une expression.

Que peut-il se passer, si on essaie d’interpréter ces briques ?

Soit \(\mathbf{f} := \lambda x.x\). Clairement, c’est une fonction d’identité car elle mappe \(x\) à \(x\). Dans le λ-calcul, on peut l’appliquer à n’importe quel terme, y compris \(\mathbf{f}\) lui-même :

\(\mathbf{f} \; \mathbf{f} = \lambda x.x \; \mathbf{f} = \mathbf{f}\)

Autrement dit, nous avons prouvé que \(\mathbf{f}(\mathbf{f}) = \mathbf{f}\). Toutefois, cela n’a aucun sens car, en mathématiques, une fonction ne peut pas être incluse dans son propre domaine de définition ! En conclusion, l’application de λ-termes reste une opération formelle. Il est même dangereux de l’interpréter comme l’application d’une fonction classique à son argument, malgré l’aspect séduisant de cette approche. La différence, toutefois, est qu’une formule formelle ne se traduit pas obligatoirement en règle bien précise.

Prise en main : booléens et branchement

Dans le λ-calcul non typé, il n’existe qu’une seule primitive : les fonctions. Pour l’utiliser comme modèle de programmation, à nous de créer tous les objets, même les plus élémentaires tels que les nombres ou les constantes booléennes.

Commençons par les dernières. Les λ-termes \(\mathbf{tru}\) et \(\mathbf{fls}\) ci-dessous jouent respectivement les rôles de “vrai” et de “faux”.

  • \(\mathbf{tru} := \lambda t.\lambda f.t \quad\) — est une fonction qui renvoie son premier argument
  • \(\mathbf{fls} := \lambda t.\lambda f.f \quad\) — est une fonction qui renvoie son deuxième argument

Pour l’instant, ces termes ne sont que des formules formelles qui manquent de contexte. Notre contexte sera le terme de branchement \(\mathbf{if}\) :

\(\mathbf{if} := \lambda b.\lambda x.\lambda y.b \; x \; y\)

Ici, \(b\) est une condition de branchement, \(x\) est une branche “then” et \(y\) correspond à “else”. Donc, pour justifier que \(\mathbf{tru}\) et \(\mathbf{fls}\) correspondent aux constantes logiques, nous avons besoin de démontrer deux égalités :

  • \( \mathbf{if} \; \mathbf{tru} \; t \; e = t\)
  • \( \mathbf{if} \; \mathbf{fls} \; t \; e = e\)

Faisons le. Pour notre premier calcul en λ, n’oublions pas que ce calcul est une serie d’applications de règles décrites ci-dessus (\(\alpha\)-équivalence et \(\beta\)-réduction) jusqu’à l’obtention d’un terme le plus simple possible sur lequel il est impossible d’appliquer l’une de ces deux règles.

Preuve. Calculons l’expression \(\mathbf{if} \; \mathbf{fls} \; t \; e\). Dans la série de réductions ci-dessous, nous soulignons la partie de l’expression à laquelle on applique la règle de calcul.
\( \mathbf{if} \; \mathbf{fls} \; t \; e = \)
\( = \underline{(\lambda b. \; \lambda x. \; \lambda y. \; b \; x \; y) \; \mathbf{fls}} \; t \; e
\qquad \text{ — par définition de $\mathbf{if}$}\)
\( = \underline{(\lambda x. \; \lambda y. \; \mathbf{fls} \; x \; y) \; t} \; e
\qquad \text{ — par $\beta$-réduction de $\lambda b$}\)
\( = \underline{(\lambda y. \; \mathbf{fls} \; t \; y)} \; e
\qquad \text{ — par $\beta$-réduction de $\lambda x$}\)
\( = \mathbf{fls} \; t \; e
\qquad \text{ — par $\beta$-réduction de $\lambda y$}\)
\( = \underline{(\lambda t. \; \lambda f. \; f) \; t} \; e
\qquad \text{ — par définition de $\mathbf{fls}$}\)
\( = \underline{(\lambda f. \; f)} \; e
\qquad \text{ — par $\beta$-réduction de $\lambda t$}\)
\( = e
\qquad \text{ — par $\beta$-réduction de $\lambda f$}\)
Q.E.D. (ou C.Q.F.D.)

Un lecteur curieux peut vérifier par lui-même que \(\mathbf{if} \; \mathbf{tru} \; t \; e = e\).
De plus, un vrai passionné peut essayer de trouver les bonnes expressions pour la conjonction (\(\mathbf{and}\)), la disjonction (\(\mathbf{or}\)) ainsi que la négation (\(\mathbf{not}\)).

Spoiler :

  • \(\mathbf{and} = \lambda x. \; \lambda y. \; x \; y \; \mathbf{fls}\)
  • \(\mathbf{or} = \lambda x. \lambda y. \; x \; \mathbf{tru} \; y\)
  • \(\mathbf{not} = \lambda x. \; x \; \mathbf{fls} \; \mathbf{tru}\)

 

Avec ces opérations supplémentaires, il est possible de prouver des formules plus longues (ne le faites pas chez vous — le calcul risque d’être bien plus long).

\(\mathbf{if} \; ((\mathbf{not} \; \mathbf{fls}) \; \mathbf{or} \; (\mathbf{fls} \; \mathbf{and} \; \mathbf{tru})) \; t \; e = t\)

To be continued…

Dans la suite, nous allons construire une arithmétique basée uniquement sur les règles du λ-calcul. Et, cerise sur le gâteau, nous programmerons le calcul d’une factorielle en utilisant uniquement un langage de λ, comme c’était promis au début de l’article !

Réferences

  • Henk Barendregt: The impact of the lambda calculus in logic and computer science. Bulletin of Symbolic Logic 3(2): 181-215 (1997)
  • Henk Barendregt: Lambda Calculus. Its Syntaxin and Semantics. Studies in logic and the foundations of Mathematics, Rijksuniversiteit Utrecht, The Netherlands (1981)
  • Felice Cardone, Hindley 1. Roger: History of Lambda calculus and Combinatory Logic. (2006)
  • Peter Selinger: Lecture Notes on the Lambda Calculus
  • Notes de cours de l’université russe IFMO

Laisser un commentaire

MERITIS ICI. ET LÀ.

Carte Meritis

Meritis Finance

5 – 7, rue d’Athènes
75009 Paris

+33 (0) 1 86 95 55 00

contact@meritis.fr

Meritis PACA

Les Algorithmes – Aristote B
2000 Route des Lucioles
06901  Sophia Antipolis Cedex

+33 (0) 4 22 46 31 00

contact@meritis-paca.fr

Europarc de Pichaury – Bâtiment B5
13290 Aix-en-Provence

+33 (0) 4 22 46 31 00

contact@meritis-paca.fr

Meritis Technologies

5 – 7, rue d’Athènes
75009 Paris

contact@meritis-technologies.fr

+33 (0) 1 86 95 55 00


Contactez-nous

Pour connaître et exercer vos droits, concernant l'utilisation des données collectées par ce formulaire, veuillez consulter la page sur notre politique de confidentialité.