-calcul avec réflexion

23

Je recherche un calcul simple qui prend en charge le raisonnement sur la réflexion , à savoir l'introspection et la manipulation des programmes en cours d'exécution.

Existe-t-il une extension -calculus non typée qui permet de convertir termes en une forme qui peut être manipulée syntaxiquement puis évaluée par la suite? $\lambda$ $\lambda$

J'imagine que le calcul a deux termes supplémentaires principaux:

$\mathtt{reflect}\ v$ : prend et produit une représentation de modifiable en manipulation syntaxique. $v$ $v$
$\mathtt{eval}\ v$ : prend une représentation syntaxique d'un terme et l'évalue.

Afin de soutenir la réflexion, une représentation syntaxique des termes est requise. Cela ressemblerait à quelque chose comme:

$\lambda x.e$ serait représenté comme un terme , où est la version reflétée de , $(\mathsf{LAM}\ R(e))$ $R(e)$ $e$
$e\ e'$ serait représenté par le terme , et $(\mathsf{APP}\ R(e)\ R(e'))$
$x$ serait représenté par . $(\mathsf{VAR}\ x)$

Avec cette représentation, la correspondance de motifs pourrait être utilisée pour manipuler des termes.

Mais nous rencontrons un problème. et doivent être codés en termes, tout comme la correspondance de motifs. Traiter cela semble être simple, en ajoutant , et , mais aurai-je besoin d'ajouter d'autres termes pour prendre en charge leur manipulation? $\mathtt{reflect}$ $\mathtt{eval}$ $\mathsf{REFLECT}$ $\mathsf{EVAL}$ $\mathsf{MATCH}$

Il y a des choix de conception à faire. Que doit faire la fonction mentionnée ci-dessus avec le corps de et ? Est-ce que devrait transformer le corps ou non? $R(-)$ $\mathtt{reflect}$ $\mathtt{eval}$ $R(-)$

Comme je ne suis pas tellement intéressé par l'étude de la réflexion elle-même - le calcul servirait de véhicule à d'autres recherches - je ne veux pas réinventer la roue.

Existe-t-il des calculs qui correspondent à ce que je viens de décrire?

Pour autant que je sache, des calculs tels que MetaML, suggérés dans un commentaire, vont très loin, mais ils n'incluent pas la possibilité de filtrer et de déconstruire des fragments de code qui ont déjà été construits.

Une chose que j'aimerais pouvoir faire est la suivante:

$\mathtt{let}\ x=\lambda y.y\ \mathtt{in}\ \mathtt{reflect}\ x \to (\mathsf{LAM}\ (\mathsf{VAR}\ y)\ (\mathsf{VAR}\ y))$

Ensuite, effectuez une correspondance de modèle sur le résultat pour créer une expression complètement différente.

Ce n'est certainement pas une extension conservatrice du -calculus et la méta-théorie est susceptible d'être laide, mais c'est un peu le point pour mon application. Je veux séparer -abstractions. $\lambda$ $\lambda$

— Dave Clarke
source

MetaML est un langage de réflexion typé avec l'opérateur de bracketing effectuant votre REFLECT et débrackant l'EVAL. Le typage est basique, mais vous pouvez voir le fragment hérité du modal S4 dans un travail comme cet article qui peut vous aider.

— ex0du5

@ ex0du5: Merci, mais cela ne va pas assez loin, pour autant que je sache. Bien sûr, je peux créer du code en plusieurs phases, mais je ne semble pas être capable de déchirer les termes. (Je vais lire de plus près, pour voir si j'ai raté quelque chose.)

— Dave Clarke

Schéma (sans mutabilité et autres complications)?

— Gilles 'SO- arrête d'être méchant'

@Gilles: Scheme est un langage de programmation, pas un calcul. De plus, je ne pense pas qu'il puisse faire ce que je veux.

— Dave Clarke

@DaveClarke Un langage de programmation est un calcul avec beaucoup de verrues. Un noyau Scheme semble approprié à première vue, mais je n'ai pas suffisamment réfléchi à vos besoins. Que pensez-vous ne fonctionnerait pas? (Rendez -vous pour discuter si vous le souhaitez.)

— Gilles 'SO- arrêtez d'être méchant'

15

Jean Louis Krivine a présenté un calcul abstrait qui étend la "Machine Krivine" d'une manière très non triviale (notez que la machine Krivine prend déjà en charge l'instruction call / cc de lisp):

Il introduit un opérateur "quote" dans cet article défini de la manière suivante: si est un -term, notez l'image de par une bijection des termes lambda aux nombres naturels. Notez le chiffre de l'église qui correspond à . Krivine définit l'opérateur par la règle d'évaluation: Je pense que la magie de Kleene montrera que cela suffit pour faire ce que vous souhaitez: définir un devis et une évaluation opérateurs, si est calculable. $\phi$ $\lambda$ $n_\phi$ $\phi$ $\pi: \Lambda \rightarrow \mathbb{N}$ $\overline{n}$ $n\in\mathbb{N}$ $\chi$

χ ϕ \to ϕ \bar{n_{ϕ}}

$\chi\ \phi \rightarrow \phi\ \overline{n_\phi}$

π

$\pi$

Notez que Krivine est notoirement difficile à lire (s'il vous plaît ne vous fâchez pas si vous lisez ceci, Jean-Louis!), Et certains chercheurs ont fait l'acte de bienfaisance en essayant d'extraire le contenu technique d'une manière plus lisible. Vous pourriez essayer de jeter un œil à ces notes de Christophe Raffali.

J'espère que cela t'aides!

Il me semble qu'il existe une autre référence qui peut être pertinente pour vos intérêts: le Pure Pattern Calculus de Jay et Kesner formalise une variante du -calculus qui étend l'abstraction simple sur une variable à une abstraction sur un motif représentant un motif le calcul lui-même. Ceci est phénoménalement expressif et permet notamment de déconstruire une application elle-même: si je ne me trompe pas, le terme: $\lambda$

(λ (x y) . x) ((λ x . x x) (λ y . y))

$(\lambda (x\ y). x)((\lambda x.x\ x)\ (\lambda y.y))$

réduit à . Encore une fois, je pense que c'est plus que suffisant pour implémenter les opérateurs quote et eval . $\lambda x.x\ x$

— cody
source

Je voudrais voter en faveur de cette réponse apparemment raisonnable, mais je n'ai aucune idée si elle commence même à répondre à la question.

— Raphael

@Raphael lisez les articles et découvrez :) En vérité, ce n'est qu'une réponse partielle: les articles formalisent en effet une caractéristique importante de lisp non trouvée dans le calcul lambda: à savoir l'opérateur QUOTE. Il n'y a cependant aucune étude méta-théorique approfondie, ils l'introduisent simplement comme un moyen d'exprimer une sorte de calcul étrange non transparent afin de réaliser des axiomes compliqués de la théorie des ensembles.

— cody

1

Si je me souviens bien, en PPC, vous ne pouvez pas faire de correspondance de motifs sur les redex, la raison qu'ils ont donnée est pour des raisons de confluence. De plus, dans PPC, la correspondance de modèle est stricte sur la correspondance, donc sera immédiatement normalisé en , la tentative de mise en correspondance avec le modèle échouera.

(λ x . x x) (λ y . y)

$(\lambda x . x\ x)\ (\lambda y . y)$

λ y . y

$\lambda y . y$

(x y)

$(x\ y)$

— jour

1

La seule citation que je connaisse est celle de Lisp. Mais, si je me souviens bien, cela ne fait que changer tout ce qui est cité en objet syntaxique. La "fonction" prend son argument non évalué. La fonction est censée prendre la valeur de son argument (l'évaluer) et la en une expression syntaxique qui évalue (comment?) à cette valeur. Donc, si le formalisme de Krivine traite du LISP , nous sommes loin de ce qui est suggéré dans la question.

q u o t e

$\mathtt{quote}$

r e f l e c t

$\mathtt{reflect}$

q u o t e

$\mathtt{quote}$

— babou

8

Cela est très difficile, voire impossible, sans renoncer à la confluence. C'est-à-dire que je soupçonne que vous avez raison au sujet d'une méta-théorie velue. D'autre part, il est possible de concevoir un calcul combinateur qui peut exprimer toutes les fonctions calculables de Turing, et qui a la pleine capacité d'inspecter ses termes: voir Jay et Give-Wilson .

Je crois cependant que cette capacité nuit à votre théorie équationnelle. En particulier, vous n'aurez tendance à prouver que deux valeurs sont égales si les sont égales jusqu'aux équivalences alpha.

Je n'ai pas encore lu le livre de Krivine lié à, mais je dois noter que dans la logique classique, vous n'avez essentiellement que deux choses: vrai et faux. Tout est équivalent à l'un d'eux. Autrement dit, vous avez de toute façon tendance à avoir une théorie équationnelle effondrée.

— Philip JF
source

1

Notez que le calcul de Krivine n'est pas un calcul de propositions mais plutôt des réalisateurs pour celles-ci, qui ont une théorie équationnelle non triviale.

— cody

5

Dans la théorie des langages de programmation, la fonctionnalité dont vous parlez est généralement appelée "citation". Par exemple, John Longley a écrit à ce sujet dans certains de ses travaux, voir cet article .

Si vous êtes juste après des considérations théoriques (par opposition à une implémentation réellement utile), vous pouvez simplifier les choses en déclarant que quote(ou reflectcomme vous l'appelez) correspond au type d'entiers naten renvoyant un code Gödel de son argument. Vous pouvez ensuite décomposer le nombre comme vous le feriez pour un arbre de syntaxe abstraite. De plus, vous n'en avez pas besoin evalcar cela peut être implémenté dans la langue - c'est essentiellement un interprète pour la langue.

Pour un modèle concret qui possède ces caractéristiques, vous pouvez considérer la première algèbre combinatoire de Kleene: interpréter tout comme un nombre (les considérer comme des codes de Gödel) et définir l'application Kleene pour signifier où est le -th fonction partielle. Cela vous donnera un modèle de -calculus (avec des cartes partielles) dans lequel est simplement la fonction d'identité. Aucune autre fonctionnalité ne doit être ajoutée à la langue. $n \star m$ $\varphi_n(m)$ $\varphi_n$ $n$ $\lambda$ quote

Si vous me dites ce que vous recherchez, je pourrai peut-être vous donner des références plus précises.

Au fait, voici un problème ouvert:

Enrichissez -calculus (typé ou non) avec lequel est une congruence de telle manière que vous conservez la règle . $\lambda$ quote $\xi$

La règle ,. E_1 ,. indique que -abstraction est une congruence. Cela nous permet de réduire under pour ainsi dire. En combinaison avec cela devient problématique, car est censé être également une congruence, donc par exemple nous voir que ce doit être le cas que Donc, d'une manière ou d'une autre, cela est censé calculer des codes Gödel "très canoniques" - mais même en supposant que nous avons un typé $\xi$

\frac{e_{1} \equiv e_{2}}{λ x . e_{1} \equiv λ x . e_{2}}

$\frac{e_1 \equiv e_2}{\lambda x \,.\, e_1 \equiv \lambda x \,.\, e_2}$

λ

$\lambda$

λ

$\lambda$ quotequote

\frac{e_{1} \equiv e_{2}}{q u o t e e_{1} \equiv q u o t e e_{2}},

$\frac{e_1 \equiv e_2}{\mathtt{quote}\,e_1 \equiv \mathtt{quote}\,e_2},$

q u o t e ((λ x . x) y) \equiv q u o t e y .

$\mathtt{quote}\,((\lambda x \,.\,x) y) \equiv \mathtt{quote}\, y.$ quote

λ

$\lambda$ -calcul sans récursion cela semble difficile à faire.

— Andrej Bauer
source

Bien sûr, il y a une conversion là-bas. Je suppose que j'aurais dû dire que cela doit être une congruence pour toutes les règles de -calculus, mais en particulier que la règle est difficile à conserver.

β

$\beta$ quote

λ

$\lambda$

ξ

$\xi$

— Andrej Bauer

La règle et la règle sont indépendantes l'une de l'autre. Veuillez ne pas confondre la théorie équationnelle avec des incarnations algorithmiques particulières.

ξ

$\xi$

β

$\beta$

— Andrej Bauer

L'article suivant montre quelques problèmes avec l'équation (ξ): Le calcul lambda est algébrique, Peter Selinger. Intéressant, quelque chose de nouveau que je n'étais pas au courant! Cool.

— Transfinite Numbers

4

Voici une réponse alternative, au lieu d'utiliser mon approche nominale qui est encore expérimentale, il existe une approche plus établie qui remonte à l'article:

LEAP: un langage avec éval et polymorphisme
Frank Pfenning et Peter Lee
https://www.cs.cmu.edu/~fp/papers/tapsoft89.pdf

Le document commence par:

Cela nous a ensuite conduit à la question, posée pour la première fois par Reynolds, de savoir si les langues fortement typées admettent des interprètes métacirculaires. La sagesse conventionnelle semblait indiquer que la réponse était "non". Notre réponse est "Presque".

Veuillez noter que LEAP est beaucoup plus fort que ce que le PO souhaite. Tout d'abord, il est tapé. Et deuxièmement, il demande la métacircularité, ce qui signifie par exemple que eval peut exécuter sa propre définition. Dans Prolog, vous obtenez la métacircularité pour résoudre / 1:

solve(true).
solve((A,B)) :- solve(A), solve(B).
solve(H) :- clause(H,B), solve(B).

Si vous ajoutez la clause suivante pour résoudre / 1:

solve(clause(H,B)) :- clause(H,B).

Et si vous faites en sorte que la clause / 2 renvoie également les clauses de résoudre / 1. Vous pouvez alors appeler résoudre (résoudre (...)) et voir comment résoudre s'exécute lui-même.

Les questions d'auto-représentation suscitent encore des recherches, voir par exemple:

Auto-représentation dans le système Girards U
Matt Brown, Jens Palsberg
http://compilers.cs.ucla.edu/popl15/popl15-full.pdf

— Nombres transfinis
source

3

Le problème est identifié à proximité des assistants de preuve tels que Coq et Isabelle / HOL. Il passe sous l'acronyme HOAS . Il y a certaines affirmations autour de λ-Prolog selon lesquelles, grâce au nouveau quantificateur such, de telles choses peuvent être faites. Mais je n'ai pas encore pu saisir cette affirmation. Je suppose que le principal aperçu que j'ai obtenu jusqu'à présent est qu'il n'y a pas d'approche définitive, il y a quelques approches possibles.

Ma propre version, pas encore terminée , s'inspire d'un article récent de Paulson sur la preuve de l'inachèvement de Gödels. J'utiliserais les classeurs au niveau objet en relation avec une structure de données qui a les noms de niveau méta. Fondamentalement, une structure de données similaire mais distincte de celle de l'OP, et avec le codage de l'Église car je suis intéressé par les types dépendants:

datatype Expr = var Name                 /* written as n */
              | app Expr Expr            /* written as s t */
              | abs Name Expr Expr       /* written as λn:s.t */

Les expressions de niveau méta peuvent être distinguées des expressions de niveau objet en ce que nous utilisons les noms de variable n, m, .. etc. pour désigner les noms. Alors que nous utilisons les noms de variables x, y, .. etc. au niveau de l'objet. L'interprétation d'un méta-terme dans la logique d'objet fonctionnerait alors comme suit. Écrivons [t] σ pour l'interprétation du terme nominal t dans le contexte nominal σ, qui devrait donner un terme objet. On aurait alors:

 [n]σ = lookup σ n
 [s t]σ = [s]σ [t]σ
 [λn:s.t]σ = λx:[s]σ.[t]σ,n:x

Ce qui précède définirait ce que l'OP appelle une fonction EVAL. Petite différence avec Paulson, σ n'est qu'une liste finie et non une fonction. À mon avis, il ne serait possible d'introduire qu'une fonction EVAL et non une fonction REFLECT. Étant donné qu'au niveau de l'objet, vous pouvez avoir une certaine égalité afin que les différentes expressions lambda soient identiques. Ce que vous devez faire serait d'utiliser eval pour raisonner éventuellement sur la réflexion si vous en ressentez le besoin.

Vous auriez besoin d'aller à des extrêmes comme Prolog où rien n'est développé, si vous voulez abattre le mur entre nominal et non nominal. Mais comme le montre l'exemple du système λ-Prolog, dans le cas d'ordre supérieur, il y a des problèmes supplémentaires qui ne peuvent par exemple être surmontés que de manière logique en introduisant de nouveaux moyens tels qu'un quantificateur ∇!

— Nombres transfinis
source