Étapes de réduction du calcul lambda
J'étudie le Lambda Calculus et je suis bloqué sur la réduction .... Quelqu'un peut-il expliquer les types de réduction avec cet exemple, en particulier la réduction bêta de la manière la plus simple possible. Cela ne me dérangerait pas non plus un tutoriel facile à comprendre.
(λxyz .xyz )(λx .xx )(λx .x )x
Calcul lambda
Le calcul lambda a une façon de se dérouler en plusieurs étapes, ce qui rend la résolution des problèmes fastidieuse, et cela peut sembler très difficile, mais ce n'est pas vraiment si mauvais. Dans le calcul lambda, il n'y a que des lambdas, et tout ce que vous pouvez faire avec eux est la substitution. Les lambdas sont comme une fonction ou une méthode - si vous êtes familier avec la programmation, ce sont des fonctions qui prennent une fonction en entrée et renvoient une nouvelle fonction en sortie.
Il existe essentiellement deux processus et demi dans le calcul lambda:
1) Conversion alpha - si vous appliquez deux expressions lambda avec le même nom de variable à l'intérieur, vous changez l'une d'entre elles en un nouveau nom de variable. Par exemple (λx.xx) (λx.x) devient quelque chose comme (λx.xx) (λy.y) ou (λx.xx) (λx'.x ') après réduction. Le résultat est équivalent à ce que vous avez commencé, juste avec différents noms de variables.
2) Réduction bêta - essentiellement une substitution. Il s'agit du processus d'appel de l'expression lambda avec entrée et d'obtention de la sortie. Une expression lambda est comme une fonction, vous appelez la fonction en substituant l'entrée tout au long de l'expression. Prenez (λx.xy) z, la seconde moitié de (λx.xy), tout après la période, est sortie, vous conservez la sortie, mais remplacez la variable (nommée avant la période) par l'entrée fournie. z est l'entrée, x est le nom du paramètre, xy est la sortie. Trouvez toutes les occurrences du paramètre dans la sortie et remplacez-les par l'entrée et c'est ce à quoi il se réduit, donc (λx.xy)z => xy avec z substitué à x, qui est zy.
2.5) Conversion Eta/Réduction Eta - Il s'agit d'une réduction de cas spécial, que j'appelle seulement la moitié d'un processus, car c'est un peu la réduction bêta, un peu comme dans techniquement, ce n'est pas le cas. Vous pouvez le voir écrit sur wikipedia ou dans un manuel car "la conversion Eta convertit entre λx. (F x) et f chaque fois que x n'apparaît pas libre dans f", ce qui semble vraiment déroutant. Tout ce que cela signifie vraiment, c'est λx. (F x) = f si f n'utilise pas x. si cela a un sens, mais est mieux illustré par un exemple. Considérons (λx. (Λy.yy) x), ceci est équivalent par la réduction eta à (λy.yy), car f = (λy.yy), qui n'a pas de x, vous pouvez le montrer en le réduisant , comme cela résoudrait en (λx.xx), ce qui est observablement la même chose. Vous avez dit de vous concentrer sur la réduction bêta, et donc je ne vais pas discuter de la conversion ETA dans les détails qu'elle mérite, mais beaucoup de gens s'y sont mis sur l'échange de pile de la théorie cs
Sur la notation de la réduction bêta:
Je vais utiliser la notation suivante pour remplacer l'entrée fournie dans la sortie:
(λ param . output)input => output [param := input] => result
Cela signifie que nous substituons les occurrences de param dans la sortie, et c'est ce qu'il réduit à
Exemple:
(λx.xy)z
= (xy)[x:=z]
= (zy)
= zy
Assez de théorie, résolvons cela. Lambda Calculus est très amusant.
Le problème que vous avez rencontré peut être résolu uniquement avec la conversion alpha et la réduction bêta, ne soyez pas intimidé par la durée du processus ci-dessous. C'est assez long, sans doute, mais aucune étape pour le résoudre n'est vraiment difficile.
(λxyz.xyz) (λx.xx) (λx.x) x
= (((λxyz.xyz) (λx.xx)) (λx.x)) x - Ajoutons la parenthèse dans "Ordre normal", associativité gauche, abc se réduit comme ((ab) c), où b est appliqué à a, et c est appliqué au résultat de cette
= (( (λxyz.xyz) (λx.xx) ) (λx.x)) x - Sélectionnez l'application imbriquée la plus profonde et réduisez-la en premier.
La section en gras se réduit comme suit:
(λxyz.xyz) (λx.xx)
= (λx.λyz.xyz) (λx.xx) - signifie la même chose, mais nous retirons le premier paramètre car nous allons le réduire et je veux donc qu'il soit clair
= (λx.λyz.xyz) (λx'.x'x ') - Conversion alpha, certaines personnes s'en tiennent aux nouvelles lettres, mais j'aime ajouter des chiffres à la fin ou `s, dans les deux cas, ça va. Étant donné que les deux expressions utilisent le paramètre x, nous devons les renommer d'un côté, car les deux X sont des variables locales et n'ont donc pas à représenter la même chose.
= (λyz.xyz) [x: = λx'.x'x '] - Notation pour une réduction bêta, nous supprimons le premier paramètre et remplaçons ses occurrences dans la sortie par ce qui est appliqué [a: = b] dénote que a doit être remplacé par b.
= (λyz. (λx'.x'x ') yz) - La réduction réelle, nous remplaçons l'occurrence de x par l'expression lambda fournie.
= (λyz. ( (λx'.x'x ') y) z) - Ordre normal pour la parenthèse à nouveau, et regardez, une autre application pour réduire , cette fois y est appliqué à (λx'.x'x '), donc réduisons cela maintenant
= (λyz. ((x'x ') [x': = y]) z) - Mettez ceci en notation pour la réduction bêta.
= (λyz. (yy) z) - nous échangeons les deux occurrences de x'x 'pour Ys, et ceci est maintenant entièrement réduit.
Ajoutez ceci de nouveau dans l'expression originale:
(( (λxyz.xyz) (λx.xx) ) (λx.x)) x
= ((λyz. (yy) z) (λx.x)) x - Ce n'est pas nouveau, il suffit de remettre ce que nous avons trouvé précédemment.
= ( (λyz. (yy) z) (λx.x) ) x - Saisissez l'application imbriquée la plus profonde, elle est de (λx.x) appliqué à (λyz. (yy) z)
Nous allons à nouveau résoudre ce problème séparément:
(λyz. (yy) z) (λx.x)
= (λy.λz. (yy) z) (λx.x) - Il suffit de faire ressortir le premier paramètre pour plus de clarté.
= (λz. (yy) z) [y: = (λx.x)] - Mis en notation de réduction bêta, nous sortons le premier paramètre et notons que Ys sera changé pour (λx.x)
= (λz. ( (λx.x) (λx.x) ) z) - La réduction/substitution réelle, la section en gras peut maintenant être réduite
= (λz. ( (x) [x: = λx.x] ) z) - J'espère que vous obtenez l'image maintenant, nous commençons à bêta réduire (λx.x) (λx.x) en le mettant sous la forme (x) [x: = λx.x]
= (λz. ( (λx.x) ) z) - Et il y a la substitution
= (λz. (λx.x) z ) - Nettoyé la parenthèse excessive, et que trouvons-nous, mais une autre application à traiter
= (λz. (x) [x: = z]) - Pop le paramètre x, mis en notation
= (λz. (z)) - Effectuer la substitution
= (λz.z) - Nettoyer la parenthèse excessive
Remettez-le dans l'expression principale:
( (λyz. (yy) z) (λx.x) ) x
= ( (λz.z) ) x - Remplir ce que nous avons prouvé ci-dessus
= (λz.z) x - nettoyage des parenthèses excessives, ceci est maintenant réduit à une seule application finale, x appliqué à (λz.z)
= (z) [z: = x] - réduction bêta, mise en notation
= (x) - faire la substitution
= x - nettoyer la parenthèse excessive
Donc voilà. La réponse est x, elle a été réduite simplement groovy.