Sur la notion de continuation et son application en linguistique théorique

Transcription

1 Sur la notion de continuation et son application en linguistique théorique 1- Qu est-ce qu on appelle une continuation en programmation? On appelle «continuation» le futur d un calcul. Par exemple, on peut être amené, dans un contexte donné, à faire un calcul déterminé (par exemple calculer la factorielle de n), le résultat de ce calcul devant ensuite être utilisé par une autre fonction (par exemple la fonction inverse). Cette autre fonction est alors la continuation du programme actuel. Si nos ambitions se limitent au calcul de la factorielle de n, alors la continuation est simplement la fonction identité. D une manière générale, une continuation est une fonction f. Dans l ordre normal si ϕ est la fonction courante à calculer, le calcul global s exprime par f(ϕ(n)), mais il peut y avoir un intérêt à faire apparaître la fonction f comme étant elle-même un argument, qu on donne à une nouvelle fonction (à construire), de manière à ce que le résultat soit le même. Appelons donc ϕ-barre cette nouvelle fonction, elle sera telle que : ϕ-barre(n, f) = f(ϕ(n)). On dira que c est la continuisée de ϕ. On notera (ce qui est rarement indiqué dans les livres d informatique) que si ϕ est une fonction de type a b (ici, avec la factorielle ce serait N N) et si f est de type b c, ϕ- barre est de type a (b c) c. Autrement dit, si ϕ(n) est de type b, ϕ-barre(n) est de type (b c) c. Curieusement, si on remplace c par, on passe d un objet de type b à un objet de type (b ), ou, dit autrement d une formule b à sa double négation b. Or, il n y a qu en logique classique que les deux formules sont équivalentes, d où le rapprochement qui sera fait plus tard entre le calcul des continuations et un système de typage calqué sur la logique classique (λµ-calcul). Maintenant, si nous faisons une comparaison avec la linguistique théorique, nous constatons que le passage d un type a à un type (a c) c est également connu : c est ce qu on appelle une élévation de type dans la grammaire de Montague. En général, ceci est utilisé pour les syntagmes nominaux : un SN standard a le type sémantique e (entité), mais les problèmes bien connus de la quantification interdisent qu on se contente d un tel type si on veut avoir une analyse correcte d une phrase telle que tout chat ronronne. Si on veut que le quantificateur tout s applique comme il est normal, aux deux propriétés représentées respectivement par «être un chat» et «ronronner», il faut que tout ait le type (e t) ((e t) t), et par conséquent, le SN tout chat le type (e t) t. Ainsi la fonction qui, en sémantique, retourne comme valeur «vrai» ou «faux» selon que le prédicat qui suit le SN (ici «ronronner») s applique ou non à tous les chats, est-elle la continuisée de la représentation sémantique primitivement associée au SN. Et il est bien vrai qu en effet, nous avons par ce moyen transformé un objet [[SN]] de type e, auquel en principe devait s appliquer la sémantique d un syntagme verbal ([[SV]]([[SN]]) en une fonction, de type (e t) t qui prend comme argument la continuation [[SV]] : [[SN]]-barre ([[SV]]). 2- A quoi peut bien servir la notion de continuation? En programmation, il peut arriver qu un calcul ne doive pas être poursuivi, cela pour différentes raisons : parce qu on a détecté une erreur (par exemple un caractère isolé au milieu de nombres, un 0 comme diviseur) ou bien parce que l utilisateur, dans un programme interactif, souhaite aller directement à un certain point du programme, dans ce cas, la continuation qui est passée en paramètre est tout simplement différente de la continuation «normale», attendue. Elle peut consister en une simple valeur «exit» par exemple, ou bien dans l affichage d un message d erreur («ceci n est pas un nombre»). Ainsi, peut-il être 1

2 intéressant de manipuler les continuations (nous pourrions dire plutôt les «contextes droits») comme des objets autonomes (des «citoyens de première classe», comme on dit en informatique), de manière à en changer à volonté. Certains informaticiens établissent un parallèle entre cette méthode et l usage des goto dans les langages de programmation d antan. Un goto était un moyen d aller directement, à partir d une instruction, à une certaine étiquette dans le programme en sautant complètement la suite normale de l instruction. Ici, c est toute la continuation possible qui est passée en paramètre de la fonction au lieu d une simple étiquette. Considérons l exemple suivant : il s agit d écrire une fonction qui effectue le produit des nombres d une liste L. La manière de faire standard est la suivante : (define (produit L) (if (null? L) 1 (* (car L)(produit (cdr L)))) Cette fonction récursive produit prend une liste en argument. Si la liste est vide, elle renvoie 1, sinon elle fait la multiplication du premier terme de la liste avec le produit de la queue de la liste. Si par exemple, L = (2, 3, 0, 1), il se passe ceci lors de l évaluation : (produit (2, 3, 0, 1)) = 2 * (produit (3, 0, 1)) = 2 * (3 * (produit (0, 1))) = 2 * (3 * (0 * (produit (1)))) = 2 * (3 * (0 * (1 * (produit ())))) = 2 * (3 * (0 * (1 * 1))) = 2 * (3 * (0 * 1)) = 2 * (3 * 0)) = 2 * 0 = 0 Or, cet empilement d appels à la fonction de multiplication est inutile : il suffirait de voir qu il y a un 0 dans la liste pour deviner immédiatement que le résultat va être 0. Autrement dit, ici, 0 est une valeur d exception et la technique des continuations peut s appliquer. Pour cela, il faut transformer cette fonction produit en une fonction produit-barre, qui va prendre comme arguments la liste et une variable de continuation. Soit k cette variable. On peut définir : (define (produit-barre L k) (cond ((null? L) (k 1)) ((zero? (car L)) 0) (else (produit-barre (cdr L)(lambda (p) (k (* p (car L))))))) On peut vérifier : (produit-barre (2, 3, 1) id) = (produit-barre (3, 1)(lambda (p)(id (* p 2)))) = (produit-barre (1)(lambda (p)((lambda (p)(id (* p 2)))(* p 3)))) = (produit-barre ( )(lambda (p)((lambda (p)((lambda (p)(id (* p 2)))(* p 3)))(* p 1))) = ((lambda (p)((lambda (p)((lambda (p)(id (* p 2)))(* p 3)))(* p 1))) 1) = 1 * 2 * 3 * 1 Mais aussi : (produit-barre (2, 3, 0, 1) id) = (produit-barre (3, 0, 1)(lambda (p)(id (* p 2)))) = (produit-barre (0, 1)(lambda (p)((lambda (p)(id (* p 2)))(* p 3)))) = 0 (à cause de la clause ((zero? (car L)) 0)) 2

3 Autrement dit : le résultat sort sans effectuer la moindre multiplication. Cet exemple de fonction est intéressant. Dans le calcul du produit des éléments d une liste, le contexte droit réside dans la liste non encore parcourue (le cdr). Au départ, on a à faire le produit des éléments de la liste, puis plus rien (fonction identité), mais pour cela, il faut faire la multiplication du produit du cdr de la liste avec le car, autrement dit quand on aura fait le produit du cdr, le contexte aura changé : il ne s agira plus de ne «rien» faire, mais de faire encore le produit par le car de la liste, autrement dit d appliquer la fonction : (lambda (p) (k (* p (car L)))) (k étant l ancienne continuation) au cdr en question, cette fonction est la nouvelle continuation. Et à chaque pas de calcul, la continuation est donnée par cette fonction, car à chaque pas le car et le cdr changent. Ceci dit, lorsque le contexte droit commence par 0, la clause ((zero? (car L)) 0)) fait que, sans avoir à procéder à quelque calcul que ce soit, on termine l évaluation en retournant la valeur 0. Ainsi la continuation est-elle une fonction sur le contexte droit et la fonction «continuisée», en manipulant les contextes, perçoit immédiatement le cas où la valeur de sortie est 0. Il y a dans certains langages de programmation (Scheme) des fonctions qui manipulent explicitement les contextes, c est e cas call/cc (call-with-current-continuation). Supposons qu on ait une expression avec un call/cc niché à l intérieur : E = ( (call/cc (lambda(k) corps) ) l appel de call/cc lie automatiquement le paramètre k à la continuation qui suit (call/cc (lambda(k) corps) dans E. Autrement dit, quand on évalue cette forme, le contexte (les petits points) est sauvé dans la variable k. A ce moment, on évalue ce call/cc. De deux choses l une, ou bien il se trouve que k n est pas appelé et alors la fonction retourne la valeur de corps, puis le contexte est restauré et le calcul de E se poursuit normalement, ou bien k est appelé et alors le contexte k s applique à la valeur d exception, avant que le calcul se poursuive normalement. On peut écrire : E[call/cc(M)] E[M(λz.E[z])]. Un opérateur voisin est le C dit «de Felleisen» qui agit selon : E[C(M)] M(λz.E[z]). La différence est que le C en question ne retourne pas à l endroit où il est appelé de manière à continuer le calcul de façon normale. Soit par exemple : (call/cc (lambda (k)(+ 2 (* 7 (k 3))))) Le contexte est la fonction identité. La continuation (passée comme valeur à k) est donc la fonction identité : (lambda ([]) []). k est appelé dans le corps de la fonction, donc il y a exception et le résultat est donc l application de cette fonction identité à la valeur 3, d où le résultat : 3. Soit maintenant : (* 4 (+ (call/cc (lambda (k) (* 5 8))) 2)) Le contexte n est pas la fonction «identité» mais la fonction (lambda ([])(* 4 (+ [] 2))). Toutefois k n est pas appelé, donc le résultat est : (* 4 (+ (* 5 8) 2)), soit :

4 Considérons alors : (* 4 (+ (call/cc (lambda (k) (* (k 5) 8))) 2)) Cette fois k est appelé, le call/cc renvoie donc la valeur d exception 5 à laquelle s applique la continuation calculée plus haut: ((lambda ([])(* 4 (+ [] 2))) 5), ce qui donne : (* 4 (+ 5 2)) = 28. La fonction produit s écrit maintenant : (define (produit L) (call/cc (lambda (exit) (letrec ((produit-aux (lambda (L) (cond ((null? L) 1) ((zero? (car L)) (exit 0)) (else (* (car L)(produit-aux (cdr L)))))))) (produit-aux L))))) On définit à l intérieur du corps de la fonction une fonction produit-aux qui calcule le produit des nombres d une liste, avec la particularité que dès que le car de cette liste est un 0, on sort. Autrement dit, quand (car L) est 0, la forme (exit 0) doit être évaluée, cela revient à abandonner tous les calculs et à renvoyer la valeur 0. Exemple : (produit (3, 2, 0, 1)) = (produit-aux (3, 2, 0, 1)) = (* 3 (produit-aux (2, 0, 1))) = (* 3 (* 2 (produit-aux (0, 1))) = % ici, exit est appelé, le résultat est donc 0% = 0 3- Continuations et λµ-calcul L introduction des continuations a permis de concevoir les changements de continuation, autrement dit les «sauts» d une instruction à une autre. Cela suppose que différentes instructions soient «étiquetées» (comme pour l utilisation d un goto), ou encore «nommées». Du point de vue de la logique, cela correspond à des formules (qui correspondent aux types des fonctions) munies d un nom. On introduit donc désormais deux types de variables : les λ-variables (pour un usage standard en lambda-calcul) et de nouvelles variables : les µ-variables, qui servent à nommer des formules. Dans un séquent, il y a donc désormais deux séries de formules : celles qui sont étiquetées par des lambda-variables (à gauche du séquent) et celles qui sont étiquetées par des mu-variables (à droite du séquent). On ne doit évidemment pas confondre les deux sortes de variables. Donner un nom à une formule, c est s autoriser à pouvoir l atteindre par la suite, en dehors de tout ordre séquentiel imposé. Quand un terme t (associé à une formule) est nommé par une étiquette α, cela se note : [α]t. Quand une formule nommée devient active, cela se représente par la µ-abstraction sur le nom : µα.e. Quand un λµ-terme µα.m est appliqué à un argument N, cet argument est passé seulement aux sous-termes de M nommés par α, d où la règle de réduction : (µα.m) N µα.m[n/*α] 4

5 où la substitution un peu particulière «/*» est telle que : 1. si M est une λ-variable x : x[n/*α] = x ; 2. si M est un λ-terme λx.m, (λx.m) [N/*α] = λx.m[n/*α] ; 3. etc. 4. si M est un µ-terme µβ.m, (µβ.m)[n/*α] = µβ.m[n/*α] ; 5. si M est [α]m : ([α]m)[n/*α] = [α](m[n/*α]n) ; 6. si M est [β]m : ([β]m)[n/*α] = [β](m[n/*α]) si β α La clause (5) doit ici être remarquée : Soit un terme [α]m, le fait de «substituer N» dans ce terme consiste à garder l étiquette α, mais pour un nouveau terme, qui s obtient en appliquant M (dans lequel on a substitué N) à N. Soit par exemple le λµ-terme : λy. µα. [β] (y λx. µδ. [α]x). On a : ((((λy. µα. [β] (y λx. µδ. [α]x) u) a) b) se réduit à : ((µα. [β] (u λx. µδ. [α]x) a) b) par β-réduction ordinaire - (µα. [β] (u λx. µδ. [α] (x a)) b) par µ-réduction - µα. [β] (u λx. µδ. [α] ((x a) b)) idem Bien noter que, au pas 2 : on réduit (µα. [β] (u λx. µδ. [α]x) a), en appliquant les règles cidessus, cela donne : (µα. [β] (u λx. µδ. [α]x) a) µα. ([β] (u λx. µδ. [α]x) a)[a/*α]) µα. [β] ((u λx. µδ. [α]x) a)[a/*α]) µα. [β] ((u[a/*α] λx. µδ. [α]x[a/*α])) a) µα. [β] ((u λx. µδ. [α]x [a/*α])) a) µα. [β] (u λx. µδ. [α](x a)) Autrement dit, tout terme de la forme [α]x est remplacé par [α](x a) Finalement, quelque soit le nombre d arguments, ( (((λy. µα. [β] (y λx. µδ. [α]x) u) v1) v2) vn) se réduit à : µα. [β] (u λx. µδ. [α]( (x v1) vn)) Le fait que l étiquette α soit conservée fait que l on peut appliquer un tel λµ-terme à une suite quelconque de termes : on n est pas obligé comme dans le λ-calcul standard de prévoir exactement le nombre de termes auquel on veut appliquer l opérateur. Examinons maintenant le comportement de l opérateur de Felleisen : E[C(M)] M(λz.E[z]) 1 Soit α et β des types arbitraires. Supposons que E soit de type β et que le trou dans E attende un terme de type α, alors λz.e[z] est de type α β. Comme les deux côtés de la réduction sont de type β, M doit être de type (α β) β, mais C(M) doit être de type α (compte tenu de ce que nous avons dit sur le trou dans E), donc C fait passer d un objet de type (α β) β à un objet de type α : c est un opérateur d abaissement de type (type-lowering). Mais en logique intuitionniste, si on a bien la règle de montée de type α - (α β) β, en revanche on n a pas la règle correspondante d abaissement. Pour cela, il faut se placer dans la logique classique, qui autorise l élimination de la double négation. Si en effet, on interprète ici β 1 Je simplifie Plus précisément, l opérateur C utilise l opérateur A (abort), de sorte que : E[C(M)] M(λz. A (E[z])), A a la particularité d exécuter son argument en abandonnant complètement le contexte : E[A (M)] M. 5

6 comme le faux ( ), l opérateur C apparaît comme l élimination de la double négation, il est de type α α. T. Gr(iffin (1990) a fait remarquer que si N est un terme clos de type β, alors il est toujours possible de faire une abstraction vide de n importe quoi, éventuellement de type α β, pour n importe quel α, et alors il suffirait d appliquer C à λd.n (où d serait de type α β) pour obtenir un terme de type α. Ainsi, tout type α serait prouvable! Pour éviter cela, il faut distinguer un type β inhabité, or un tel type correspond nécessairement au «faux» :. D où l idée que le type des observables (des calculs résolus?) soit. En ce cas, d est de type α et λd.n est de type α, et on obtient le fait que α est prouvable si α est prouvable, autrement dit une application du raisonnement par l absurde. Il devient alors tentant de faire pour ce calcul la même chose que pour le λ-calcul, c est-à-dire développer un isomorphisme du genre de celui de Curry-Howard. Il faudrait pour cela, donner un ensemble de règles de logique classique, avec les opérations correspondantes dans le λµcalcul. C est ce qu a fait M. Parigot. Les règles peuvent s écrire : 1- règles usuelles pour le λ-calcul 2- règles de nommage : t : Γ - A, [α]t : Γ - α : A, e : Γ - α : A, µα. e : Γ - A, Commentaires : La première règle consiste à distinguer une formule dans le conséquent du séquent et à lui attribuer un nom (une étiquette). On repère cela par l opérateur [α]. On restaure l environnement qui a été sauvé dans α et on exécute u. La deuxième règle consiste à rendre active une formule dans le conséquent du séquent, cette formule est choisie à partir de son étiquette. On sauve l environnement courant dans α et on exécute u. Dans ce calcul, on peut extraire un λµ-terme à partir d une déduction de A à partir de A : M : - A M(λt. [α]t) : - α : A µα. M(λt. [α]t) : - A t : A - A [α]t : A - α : A λt. [α]t : - A, α : A On peut donc extraire un λµ-terme à partir d une déduction de A à partir de A A : Cet opérateur est le C de Felleisen. t : A - A [α]t : A - α : A y : A - A λt. [α]t : - A, α : A y(λt. [α]t) : y : A -, α : A µα. y(λt. [α]t) : y : A - A λy. µα. y(λt. [α]t) : - A A 6

7 Ceci dit, l évaluation en λ-calcul connaît deux types de stratégies, dites call-by-name et callby-value. Le call-by-value est l ordre «naturel», classique, consistant à évaluer d abord les valeurs des arguments avant la valeur globale de la fonction. Les définitions des différentes fonctions eval (d après Plotkin) sont les suivantes : Call-by-value : (où V est une valeur) eval(v) = V eval(m N) = eval(q[v/x]) si eval(m) = λx. Q et si eval(n) = V Call-by-name : eval(v) = V eval(m N) = eval(q[n/x]) si eval(m) = λx. Q En λ-calcul, la confluence (Church-Rosser) du calcul fait que les deux stratégies conduisent aux mêmes résultats. En λµ-calcul, elles ne produisent pas le même résultat, d où la possibilité d envisager les deux stratégies séparément, ce qui permet de se donner deux règles de µ-réduction (règles de réduction structurelles), qui en général provoqueront des divergences de calcul : une règle µ et une règle µ. P. de Groote les formule de la manière suivante : µ : ((µα.m) N) µβ.m[α t := β (t N)] µ : (N (µα.m)) µβ.m[α t := β (N t)] µ : quand un µ-terme µα.m est appliqué à un terme N, les sous-termes t auxquels s applique la continuation α sont remplacés par l application de t à N, à laquelle s applique une nouvelle continuation β, µ : quand au contraire, µα.m est dans le contexte (N []),les sous-termes t auxquels s applique la continuation α sont remplacés par l application de ce contexte à t, à laquelle s applique une nouvelle continuation β, Il propose une application assez évidente en linguistique, concernant le fameux problème des ambiguïtés de portée des quantificateurs dans une phrase comme toute personne aime un chat. Contrairement à l approche classique qui attribue les types suivants : Expression sémantique type toute personne λp. x. personne(x) (P x) (e t) t un chat λp. y. chat(y) (P y) (e t) t aime λx. λy. ((aime y) x) e (e t) la nouvelle approche a pour tableau : 7

8 Expression sémantique type toute personne µα. x. personne(x) (α x) e un chat µα. y. chat(y) (α y) e aime λx. λy. ((aime y) x) e (e t) attention : ici, α étant une µ-variable, (α y) désigne simplement le nommage de y par α ou plus précisément l application à y d un contexte (continuation) quelconque. Pour vérifier que l expression est bien de type e, il suffit de faire la déduction suivante (de Groote) : personne : e t [x : e] 1 [α : e t] 2 [x : e] 1 personne(x) : t (α x) : t personne(x) (α x) : t x. personne(x) (α x) : t µα. x. personne(x) (α x) : e Au cours du dernier pas de cette preuve, l hypothèse α est µ-déchargée. Comme elle est de type e t, si c était une λ-variable, on obtiendrait un objet de type (e t) t, mais l abstraction µα a pour fonction d abaisser le type, donc ici à e. Considérons l évaluation de l expression : ((λx. λy. ((aime y) x) µα. y. chat(y) (α y)) µα. x. personne(x) (α x) ) 1- (λx. λy. ((aime y) x) µα. y. chat(y) (α y)) se réduit à : λy. ((aime y) µα. y. chat(y) (α y)) par simple β-réduction, 2 - ((λx. λy. ((aime y) x) µα. y. chat(y) (α y)) µα. x. personne(x) (α x)) devient donc : (λy. ((aime y) µα. y. chat(y) (α y)) µα. x. personne(x) (α x)), qui se réduit à : ((aime µα. x. personne(x) (α x)) µα. y. chat(y) (α y)), là encore par simple β- réduction, 3- à ce stade, on utilise la µ -réduction : (α x) est remplacé par (β (aime x)), d où : (µβ. x. personne(x) (β (aime x))) (µα. y. chat(y) (α y)), 4- on utilise alors la µ-réduction : (β (aime x)) est remplacé par ((β (aime x (µα. y. chat(y) (α y)))), d où : (µβ. x. personne(x) (β (aime x (µα. y. chat(y) (α y)))), 5- à ce stade, P. de Groote donne une règle de simplification qui fait disparaître le β désormais inutile pour qu on obtienne : x. personne(x) (aime x (µα. y. chat(y) (α y))), 6- une dernière application de µ conduit alors au remplacement de (α y) par (α (aime x y)), qui conduit à : x. personne(x) (µα. y. chat(y) (α (aime x y))), et avec la même règle de simplification, on obtient : x. personne(x) y. chat(y) (aime x y)), Or, on aurait pu choisir un autre ordre de réduction, conduisant à une autre représentation sémantique : il suffisait au pas 4 d utiliser la µ -réduction au lieu de la µ-réduction et on obtenait à ce pas : 8

9 4 - dans (µβ. x. personne(x) (β (aime x))) (µα. y. chat(y) (α y)), (α y) est remplacé par (α (µβ. x. personne(x) (β (aime x))) y), d où : µα. y. chat(y) (α ((µβ. x. personne(x) (β (aime x))) y)), 5 par simplification : y. chat(y) ((µβ. x. personne(x) (β (aime x))) y), 6 puis par µ -réduction : y. chat(y) (µβ. x. personne(x) (β ((aime x) y))), 7 - et par simplification : y. chat(y) x. personne(x) ((aime x) y)) En résumé, on donne aux µ-variables comme α ou β, à titre de «valeurs», des continuations, ou contextes d évaluation. Ce contexte peut être soit ce qui vient après, soit ce dans quoi le terme est enchâssé, et on garde toujours une µ-variable pour la suite, sauf si, n ayant plus de suite, elle devient inutile (règle de simplification). 4- Retour aux continuations, sans µ-variables Bien sûr, on n est pas obligé d utiliser le λµ-calcul. Plotkin a montré comment gérer les continuations au sein du λ-calcul pur. Différents auteurs ont montré qu il y avait équivalence entre les deux manières de faire. Dans le cas de Plotkin, on appelle transformation-cps la manière de passer des λ-termes usuels aux λ-termes agissant sur les continuations. Cette transformation peut prendre pour modèle ce que nous avons déjà vu avec l élévation de type montagovienne : si une constante c est de type e, alors sa transformée-cps est : λk. k(c), qui est de type (e t) t. La raison en est que, comme on l a vu, le contexte normal d une telle constante est de type e t, et que, donc, elle-même, vue comme fonction de son contexte, doit être de type (e t) t. Mais il n y a aucune raison de se cantonner dans les constantes ou les noms propres ou les SN les autres objets aussi peuvent être CPS-transformés. Par exemple, si nous avons un verbe intransitif, exprimant une propriété (cf. dort, en principe de type e t), ce verbe a nécessairement pour contexte quelque chose qui, en se combinant avec le verbe de type e t, va donner une phrase, de type t, donc sa continuation est de type (e t) t, et lui-même, dans sa version continuisée (c est-à-dire prête à accueillir un tel contexte comme argument), est de type ((e t) t) t, d où sa représentation sémantique : λp*.p*(λx.dort(x)), où P* est une variable continuisée de type (e t) t. Si maintenant, on veut obtenir la représentation de Pierre dort, on ne peut plus utiliser la sémantique directe pour laquelle on avait [[Pierre dort]] = [[dort]]([[pierre]]), puisque [[Pierre]] est de type (e t) t et [[dort]] de type ((e t) t) t et que l on cherche à obtenir une phrase «continuisée» qui est de type (t t) t. Le théorème, dû à Plotkin, est le suivant (qu on peut généraliser) : Lemme : étant donnée une règle C AB, avec c = m(a, b) (où nous avons noté a, b et c les représentations sémantiques respectives de A, B et C et où m est l opération qui relie a, b et c, ici l application, c = b(a)), il existe deux règles : C AB, avec c* = m 1 (a*,b*) et C AB, avec c* = m 2 (a*,b*) qui sont telles que pour i=1, 2, m i (a*,b*)(λx.x) = m(a, b). Il suffit que m 1 et m 2 vérifient la contrainte suivante, appelée schème de continuation : m 1 (a*,b*) = λu.(a*(λx. (b* (λy u(m(x, y))))))) m 2 (a*,b*) = λu. (b*(λy. (a* (λx u(m(x, y))))))) 9

10 Démonstration : on doit d abord démontrer que pour toute fonction g et toute sémantique continuée x*, x*(λu.g(u)) = g(x). Noter qu en ce qui concerne notre lexique ci-dessus, c est bien le cas, d une manière triviale. On généralise ensuite par induction sur la structure de l expression. Ceci étant on voit alors que : [λu.(a*(λx. (b* (λy u(m(x, y)))))))] (λx.x) > a*(λx. (b* (λy (λx.x) (m(x, y)))))) > a*(λx. (b* (λy (m(x, y)))) > a*(λx. (m(x, b)))) > m(a, b) idem pour m 2 (a*,b*). Appliqué au problème particulier que nous avons ici, nous obtenons que pour une règle A BC, où en principe [[B]] s applique à [[C]], on fait en réalité dans l ordre les opérations suivantes : - on applique la continuisée de C à un schéma (λc u (c b)) - on abstrait sur b - on applique la continuisée de B, - on abstrait sur u (mais on peut avoir l autre ordre : d abord B, puis C, dans le cas particulier cela ne changera pas le résultat, alors que dans d autres cas problèmes de scopes cela le changera). Exemple : On applique [[dort]]* : - (λp*.p*(λx.dort(x)) (λc u (c b)) On obtient: (λc u (c b))(λx.dort(x)) u (λx.dort(x) b) - abstraction sur b : λb. u (λx.dort(x) b) - on applique [[Pierre]]* : [λk. k(pierre)]( λb. u (λx.dort(x)) b) [λb. u (λx.dort(x) b)](pierre) u (λx.dort(x) Pierre) u (dort(pierre)) - on abstrait sur u : λu. u (dort(pierre)) On obtient une version continuisée de la sémantique de Pierre dort. Evidemment, en changeant l ordre des instanciations (ici, c était c avant b, mais on peut faire aussi b avant c), on obtient la même chose. On peut alors facilement construire une grammaire «continuisée» (Barker, 2002) : S SN SV SV Vt SN SN Pierre SN Marie SV dort Vt regarde λu. [[SV]]* (λp. [[SN]]* (λx. u (P x))) λp. [[Vt]]* (λr. [[SN]]* (λx. P (R x))) λk. k(pierre) λk. k(marie) λp. P(λx. dort(x)) λr. R(λx. λy. regarde(y, x)) Remarque : (P x) est le schéma de composition, u est une variable de continuation. [[SN]]* occupera la place de x car x est abstrait du schéma de composition et [[SN]]* est appliqué à cette abstraction. Ensuite idem avec [[SV]]*, qui remplace P. Transformation-CPS de Plotkin On peut transformer le λ-calcul pur en un calcul sur les continuations au moyen des traductions suivantes : 10

11 c = λk. (k c) x = λk. (k x) λx. M = λk. k(λx. M) (M N) = λk. (M (λm. N(λn. (m (n k))))) % pourquoi pas : λk. (M (λm. N(λn. (k (m n)))))? NB : c est la solution retenue par C. Barker (Continuations in NL, extended abstract)% Sur la quantification Reprenons, d une manière à similaire à de Groote, le tableau suivant (mais qui n utilise pas le λµ-calcul, à la place seulement une distinction entre variables normales et variables continuisées ou «de continuation», qui sont soulignées) : toute personne un chat λα. x personne(x) α(x) λα. x chat(x) α(x) Chacune de ces expressions a pour type : (e t) t. L un des avantages est qu on peut désormais traiter de la même manière le cas où l expression quantifiée est en position de sujet et celui où elle est en position d objet. Par exemple : Pierre aime un chat : 1- aime un chat λp. [[aime]]* (λr. [[un chat]]* (λx. P (R x))) λp. [[aime]]* (λr. [λα. x chat(x) α(x)] (λx. P (R x))) λp. [[aime]]* (λr. [ x chat(x) (λx. P (R x))(x)] λp. [[aime]]* (λr. [ x chat(x) P (R x)] λp. λs. S(λx. λy. aime(y, x)) (λr. [ x chat(x) P (R x)] λp. [λr. [ x chat(x) P (R x)]](λx. λy. aime(y, x)) λp. [ x chat(x) P ((λx. λy. aime(y, x)) x)]] λp. [ x chat(x) P (λy. aime(y, x))]] 2- Pierre aime un chat λu. λp. [ x chat(x) P (λy. aime(y, x))]](λp. [λk. k(pierre)](λx. u (P x))) λu. λp. [ x chat(x) P (λy. aime(y, x))]](λp. (λx. u (P x))) (Pierre)) λu. λp. [ x chat(x) P (λy. aime(y, x))]](λp. u (P pierre))) λu. [ x chat(x) (λp. u (P pierre))) (λy. aime(y, x))]] λu. [ x chat(x) u ((λy. aime(y, x)) pierre)))]] λu. [ x chat(x) u (aime(pierre, x))] Comparons avec ce qu on aurait eu avec le λµ-calcul : ((λx. λy. ((aime y) x) µα. y. chat(y) (α y)) µα. (α pierre) ) 1- aime un chat (λx. λy. ((aime y) x) µα. z. chat(z) (α z)) λy. ((aime y) µα. z. chat(z) (α z)) (β-réduction) cf. µ : (N (µα.m)) µβ.m[α t := β (N t)] 11

12 λy. µβ. ( z. chat(z) β ((aime y) z)) 2- Pierre aime un chat (λy. µβ. ( z. chat(z) β ((aime y) z)) µα. (α pierre)) µβ. ( z. chat(z) β ((aime µα.(α pierre)) z)) µβ. ( z. chat(z) β ((aime pierre) z)) (par règle de simplification) z. chat(z) ((aime pierre) z) (par règle de simplification) Nous allons voir maintenant que le choix possible entre deux schémas de continuation, pour une règle binaire, n est pas toujours neutre et que c est de ce choix que va dépendre un scope plutôt qu un autre dans le cas d une ambiguïté de scope. Reprenons avec toute personne aime un chat. 1- aime un chat λp. [[aime]]* (λr. [[un chat]]* (λx. P (R x))) λp. [[aime]]* (λr. [λα. x chat(x) α(x)] (λx. P (R x))) λp. [[aime]]* (λr. [ x chat(x) (λx. P (R x))(x)] λp. [[aime]]* (λr. [ x chat(x) P (R x)] λp. λs. S(λx. λy. aime(y, x)) (λr. [ x chat(x) P (R x)] λp. [λr. [ x chat(x) P (R x)]](λx. λy. aime(y, x)) λp. [ x chat(x) P ((λx. λy. aime(y, x)) x)]] λp. [ x chat(x) P (λy. aime(y, x))]] Si nous formons la représentation sémantique de toute personne aime un chat, alors en appliquant la règle S SN SV, nous avons le choix entre deux continuisations possibles pour cette règle : S SN SV λu. [[SV]]* (λp. [[SN]]* (λx. u (P x))) λu. [[SN]]* (λx. [[SV]]* (λp. u (P x))) 2- toute personne aime un chat première stratégie : λu. [[SV]]* (λp. (λα. z personne(z) α(z) (λx. u (P x)))) λu. [[SV]]* (λp. ( z personne(z) u (P z)) λu. (λp. [ x chat(x) P (λy. aime(y, x))]] (λp. ( z personne(z) u (P z))) λu. ([ x chat(x) (λp. ( z personne(z) u (P z) (λy. aime(y, x)))) λu. ([ x chat(x) ( z personne(z) u (aime(z, x)))) deuxième stratégie : λu. [[SN]]* (λx. (λp. z chat(z) P (λy. aime(y, z)) (λp. u (P x)))) λu. [[SN]]* (λx. z chat(z) (λp. u (P x) (λy. aime(y, z) )) λu. (λα. w personne(w) α(w) (λx. z chat(z) u (λy. aime(x, z)))) λu. ( w personne(w) z chat(z) u (λy. aime(w, z))) Ainsi, «computationnellement», les deux règles ci-dessus correspondent à deux ordres différents d exécution ; «de gauche à droite» ou «de droite à gauche». La première règle donne la priorité au SV sur le SN, et la deuxième donne la priorité au SN sur le SV. 12

13 5- Continuations et DRT (d après P. de Groote, 2005) Soit τ la «catégorie syntaxique» des textes (ou discours). Soit e le type des individus et t celui des propositions. De Groote ajoute une catégorie atomique supplémentaire : celle des contextes gauches (je la noterai g). Avec ce typage, un contexte droit est alors un morceau de discours qui sera interprété comme une proposition s il trouve un contexte gauche approprié. Son type sera donc g t. On dira que c est le type d une continuation. Maintenant, considérons un texte «en contexte», il sera interprété comme un objet qui, étant donné un contexte gauche et un contexte droit donne une proposition de type t. d où : [[τ]] = g ((g t) t) Ici, de Groote utilise le même mécanisme que Barker : admettons qu on ait une règle simple de reconnaissance syntaxique des discours, disant en gros qu un discours se forme en agglomérant une nouvelle phrase à un discours déjà existant, quelque chose qu on peut écrire : D D S Alors on trouve le même genre de continuisation que chez Barker : (1) S D S λu. [[D]]* (λx. [[S]]* (λp. u (P x))) (sauf qu ici, on sélectionne une stratégie (l interprétation gauche-droite)), à ceci près qu on tient explicitement compte des deux contextes (gauche et droite). Si e est une variable de «contexte gauche» et φ une variable de contexte droit : [[S]] doit s appliquer à e et à φ pour donner une proposition, ensuite [[D]] soit appliquer à son propre contexte gauche e et à la proposition obtenue par S, sachant que le contexte droit du résultat (DS) et de la phrase (S) sont le même, d où la représentation sémantique de la règle (1) : λe.λφ. ([[D]] e (λe.([[s]] e, φ))) Si on considère une DRS [[x 1,, x n ] ; C 1,, C m ], elle a une traduction logique sous la forme : x 1,, x n C 1 C m. En termes de continuations toutefois, les variables x 1,, x n sont destinées à être utilisées par le contexte droit (la continuation du discours) et elles s intègrent dans un contexte gauche (éventuellement vide si c est la première phrase du discours qui est représentée) que nous noterons e. Si nous notons encore φ une telle continuation, le contexte gauche e de la continuation du discours est donc fait d une combinaison de ces variables et de e (voir comment plus tard). Finalement une version continuisée d une DRS se notera : λe. λφ. x 1,, x n C 1 C m (φ, e ) Reste à savoir comment fabriquer e à partir de e et des nouvelles variables. De Groote donne l exemple suivant : John loves Mary. He smiles at her. Admettons qu un algorithme ait indexé les entités coréférentes : John 1 loves Mary 2. He 1 smiles at her 2 13

14 Partons d un premier typage, usuel, selon lequel: John, Mary, he, her := np (e t) t loves, smiles at := np (np s) e (e t) La nouvelle approche oblige à tenir compte des contextes : [[np]] = g ((g (e t)) t) g (e t) est le type d un objet qui, à partir d un contexte gauche donne une propriété, c est donc le nouveau type qu on donne à une propriété en contexte. Maintenant, un [[np]] à partir d un contexte gauche et d une propriété (un [[SV]]) en contexte, donne une proposition : c est la nouvelle manière d élever le type d un SN en tenant compte des contextes. Plus précisément encore : le [[np]] peut utiliser son contexte gauche (première occurrence de g dans le type) de manière à y trouver sa référence (c est le cas en particulier pour un pronom), ensuite il prend pour argument une propriété contextualisée (de type g (e t), c est-à-dire un [[SV]] qui va pouvoir lui-même trouver sa référence, mais à partir des marques que justement l analyse du SN aura laissées (s il s agit d un nom propre par exemple comme John ou Mary), d où le fait qu on puisse dire que la première occurrence de g permet l accès d un pronom à son référent, alors que la deuxième occurrence de g «permet aux SN comme John ou Mary de mettre à jour le contexte, pour la suite». Ainsi un pronom, comme un nom propre, doivent-ils avoir le type ci-dessus. Comment construire la représentation sémantique correspondante? Un pronom sélectionne un indice préalablement introduit. Un nom propre introduit un nouvel indice. D où la nécessité d inclure dans leur sémantique ce type d opération qui manipule les contextes. Soit donc deux fonctions : push (pour introduire) et select (pour sélectionner). Elles sont définies comme suit : push prend pour argument un entier (valeur de l indice) et ajoute l association entre une variable de type e et cet indice dans le contexte g, donc à un entier, push associe la fonction qui, à un objet de type e, associe la fonction de changement de contexte gauche qui fait passer d un contexte antérieur γ à un contexte ultérieur γ. D où son type : N (e (g g)) Quant à select, elle prend pour argument un entier et lui associe la fonction qui, au contexte gauche existant, associe la variable (de type e) qui correspond à ce même entier. D où son type : N (g e) Push et select sont définis de telle manière que : select i (push j a l) = a si i = j = select i l, sinon nil est la liste vide (de type g). A partir de là, on peut définir la sémantique d un nom propre muni d un indice : 14

15 [[John i ]] = λe. λψ. (ψ(push i john e) john) Autrement dit: À John d indice i, on associe la fonction qui, à un contexte gauche e (de type g), et à une function ψ qui représente une propriété contextualisée, associe un individu. (push i john e) est un nouveau contexte gauche γ (il comprend l introduction de l indice i comme étant associé à John). ψ (le futur syntagme verbal) s applique à ce nouveau contexte et ψ(push i john e) donne une propriété (e t), qui en s appliquant à la constante john va bien donner une proposition. Idem évidemment pour Mary : Pour les pronoms, on a: [[Mary i ]] = λe. λψ. (ψ(push i mary e) mary) [[he i ]] = λe. λψ. (ψ e (select i e)) [[her i ]] = λe. λψ. (ψ e (select i e)) Un verbe transitif a pour type sémantique : [[np]] ([[np]] [[s]]), autrement dit, à la lettre : (g ((g (e t)) t)) ((g ((g (e t)) t)) (g ((g t) t)))) Donc: d abord, c est une fonction de la sémantique d un nom (variable o), puis d un autre nom (s), puis d un contexte gauche (e), et enfin d un contexte droit (φ) : λo. λs. λe. λφ. (s e (λe.λx. (o e (λe. λy. (love x y) (φ e ))))) o (le nom objet) est d abord appliqué à un contexte gauche quelconque e et à une fonction qui associe à tout contexte gauche et à tout y la conjonction de (love x y) et de la continuation φ appliquée à ce contexte gauche, ensuite on abstrait sur e et sur x, pour appliquer le nom sujet s à un contexte gauche quelconque e et à la fonction obtenue. On peut alors suivre la dérivation de [[loves]] [[Mary 2 ]] [[John 1 ]] : ((λo. λs. λe. λφ. (s e (λe.λx. (o e (λe. λy. (love x y) (φ e ))))) [[Mary 2 ]]) [[John 1 ]]) λe. λφ. ([[John 1 ]] e (λe.λx. ([[Mary 2 ]] e (λe. λy. (love x y) (φ e ))))) = λe. λφ. (λe. λψ. (ψ(push 1 john e) john) e (λe.λx. ([[Mary 2 ]] e (λe. λy. (love x y) (φ e ))))) λe. λφ. ((λe.λx. ([[Mary 2 ]] e (λe. λy. (love x y) (φ e ))) (push 1 john e) john)) λe. λφ. ((λx. ([[Mary 2 ]] (push 1 john e) (λe. λy. (love x y) (φ e ))) john)) λe. λφ. (([[Mary 2 ]] (push 1 john e) (λe. λy. (love john y) (φ e ))) = λe. λφ. ((λe. λψ. (ψ(push 2 mary e) mary) (push 1 john e) (λe. λy. (love john y) (φ e ))) λe. λφ. ((λψ. (ψ(push 2 mary (push 1 john e)) mary) (λe. λy. (love john y) (φ e ))) λe. λφ. (((λe. λy. (love john y) (φ e ) (push 2 mary (push 1 john e)) mary)) λe. λφ. (((λy. (love john y) (φ (push 2 mary (push 1 john e))) mary)) 15

16 λe. λφ. ((love john mary) (φ (push 2 mary (push 1 john e)))) Une fois que l on a obtenu cela pour John loves Mary, il reste à le composer avec He smiles at her. On utilise pour cela la règle de composition λe.λφ. ([[D]] e (λe.([[s]] e, φ))), sachant qu on peut obtenir la sémantique de he smiles at her sur le même modèle que celle de John loves Mary : λe. λφ. (smile (select 1 e)(select 2 e) (φ e)). On obtient: λe.λφ. ([[D]] e (λe.([[s]] e φ)) = λe.λφ. ([[D]] e (λe.(λe. λφ. (smile (select 1 e)(select 2 e)) (φ e) e φ)))) λe.λφ. ([[D]] e (λe.λφ. (smile (select 1 e )(select 2 e )) (φ e ) φ)) λe.λφ. ([[D]] e (λe. (smile (select 1 e )(select 2 e )) (φ e )))) = λe.λφ. (λe. λφ. ((love john mary) (φ (push 2 mary (push 1 john e)))) e (λe. (smile (select 1 e )(select 2 e )) (φ e )))) λe.λφ. (λφ. ((love john mary) (φ (push 2 mary (push 1 john e)))) (λe. (smile (select 1 e )(select 2 e )) (φ e )))) λe.λφ. ((love john mary) ((λe.(smile (select 1 e )(select 2 e )) (φ e ))) (push 2 mary (push 1 john e)))) λe.λφ. (love john mary) (smile (select 1 (push 2 mary (push 1 john e))) (select 2 (push 2 mary (push 1 john e)))) (φ (push 2 mary (push 1 john e))) Raffinements On doit pouvoir éviter évidemment des suites telles que: Every man loves a woman. *He smiles at her Pour cela, de Groote suggère qu on prenne en compte et les contexts gauches (g) et les contexts droits (g t). En ce cas, un nom (anciennement de type e t) deviendrait de type e (g ((g t) t)) : à partir d un individu, d un contexte gauche et d un contexte droit, on obtient une proposition, en SN deviendrait alors, au lieu de (e t) t : (e (g ((g t) t)) (g ((g t) t)) à partir d une propriété «contextualisée», obtenir une proposition si on a un contexte gauche et un contexte droit. L interprétation d un nom commun, comme homme devient : λx. λe. λφ. (homme x) (φ e) D un nom propre comme Marie est au lieu de [[Mary i ]] = λe. λψ. (ψ(push i mary e) mary) : [[Marie i ]] = λψ.λe. λφ. (ψ marie e (λe. φ(push i marie e ))) ψ est de type (e (g ((g t) t)) : prend un individu (marie), un contexte gauche (e) et un contexte droit (λe. φ(push i marie e )). Un verbe transitif comme aime a pour représentation : 16

17 [[aime]] = λo. λs. s(λx. o(λy. λe. λφ. (love x y) (φ e))) Un déterminant comme un i : [[un i ]] = λn. λψ. λe. λφ. x (n x e (λe. (ψ x (push i x e) φ))) Le n (nom) s applique à x (individu) puis au contexte gauche e puis au contexte droit λe. (ψ x (push i x e) φ) (cette dernière action permettant de sélectionner un indice i associé à un représentant du nom grâce au déterminant indéfini). Par exemple : Pierre voit un homme. Il siffle. ([[voit]] ([[un 2 ]] [[homme]]))) [[Pierre 1 ]] D abord : un homme ([[un 2 ]] [[homme]]))) = (λn. λψ. λe. λφ. x (n x e (λe. (ψ x (push i x e) φ))) λx. λe. λφ. (homme x) (φ e)) λψ. λe. λφ. x (λx. λe. λφ. (homme x) (φ e)) x e (λe. (ψ x (push 2 x e) φ))) λψ. λe. λφ. x (λe. λφ. (homme x) (φ e)) e (λe. (ψ x (push 2 x e) φ))) λψ. λe. λφ. x (λφ. (homme x) (φ e)) (λe. (ψ x (push 2 x e) φ))) λψ. λe. λφ. x (homme x) (λe. (ψ x (push 2 x e) φ)) e)) λψ. λe. λφ. x (homme x) (ψ x (push 2 x e) φ)) Ensuite: (λo. λs. s(λx. o(λy. λe. λφ. (voit x y) (φ e))) ([[un 2 ]] [[homme]])) [[Pierre 1 ]] (λs. s(λx. (([[un 2 ]] [[homme]) (λy. λe. λφ. (voit x y) (φ e)))) [[Pierre 1 ]] ([[Pierre 1 ]] (λx. (([[un 2 ]] [[homme]) (λy. λe. λφ. (voit x y) (φ e))))) = ([[Pierre 1 ]] (λx. (λψ. λe. λφ. z (homme z) (ψ z (push 2 z e) φ)) (λy. λe. λφ. (voit x y) (φ e))))) ([[Pierre 1 ]] (λx. (λe. λφ. z (homme z) ((λy. λe. λφ. (voit x y) (φ e)) z (push 2 z e) φ))))) ([[Pierre 1 ]] (λx. (λe. λφ. z (homme z) (λe. λφ. (voit x z) (φ e)) (push 2 z e) φ))))) ([[Pierre 1 ]] (λx. (λe. λφ. z (homme z) (λφ. (voit x z) (φ(push 2 z e))) φ))) ([[Pierre 1 ]] (λx. (λe. λφ. z (homme z) (voit x z) (φ(push 2 z e))))) = (λψ.λe. λφ. (ψ pierre e (λe. φ(push 1 pierre e ))) (λx. (λe. λφ. z (homme z) (voit x z) (φ(push 2 z e))))) λe. λφ. ((λx. (λe. λφ. z (homme z) (voit x z) (φ(push 2 z e)))) pierre e (λe. φ(push 1 pierre e ))) ) λe. λφ. ((λx. (λφ. z (homme z) (voit x z) (φ(push 2 z e)))) pierre (λe. φ(push 1 pierre e ))) ) λe. λφ. ((λφ. z (homme z) (voit pierre z) (φ(push 2 z e))))) λe. λφ. ( z (homme z) (voit pierre z) ((λe. φ(push 1 pierre e )) (push 2 z e))))) λe. λφ. ( z (homme z) (voit pierre z) (φ(push 1 pierre (push 2 z e)))))) Après, il sera facile de combiner avec il siffle pour obtenir la représentation cherchée. Supposons maintenant que nous donnions au quantifieur tout la représentation suivante : 17

18 [[tout i ]] = λn. λψ. λe. λφ. ( x. (n x e (λe. (ψ x (push i x e)(λe. T))))) (φ e) Alors Pierre voit tout homme donne: D abord tout homme : ([[tout 2 ]] [[homme]]))) = (λn. λψ. λe. λφ. x. (n x e (λe. (ψ x (push 2 x e)(λe. T)))) (φ e) λx. λe. λφ. (homme x) (φ e )) λψ. λe. λφ. x. (λx. λe. λφ. (homme x) (φ e ) x e (λe. (ψ x (push 2 x e)(λe. T)))) (φ e) λψ. λe. λφ. x. λφ. (homme x) (φ e) (λe. (ψ x (push 2 x e)(λe. T)))) (φ e) λψ. λe. λφ. x. λφ. (homme x) (φ e) (λe. (ψ x (push 2 x e)(λe. T)))) (φ e) λψ. λe. λφ. x. (homme x) ((λe. (ψ x (push 2 x e)(λe. T)))) (φ e) e) λψ. λe. λφ. x. (homme x) ( (ψ x (push 2 x e) (λe. T)))) (φ e)) Pierre voit tout homme: (λo. λs. s(λz. o(λy. λe. λφ. (voit z y) (φ e))) ([[tout 2 ]] [[homme]])) [[Pierre 1 ]] λs. s(λz. (([[tout 2 ]] [[homme]]) (λy. λe. λφ. (voit z y) (φ e)) [[Pierre 1 ]] [[Pierre 1 ]] (λz. (([[tout 2 ]] [[homme]]) (λy. λe. λφ. (voit z y) (φ e)) = [[Pierre 1 ]] (λz. (λψ. λe. λφ. x. (homme x) ( (ψ x (push 2 x e) (λe. T)))) (φ e)) (λy. λe. λφ. (voit z y) (φ e)) [[Pierre 1 ]] (λz. (λe. λφ. x. (homme x) ( (λy. λe. λφ. (voit z y) (φ e) x (push 2 x e) (λe. T)))) (φ e))) [[Pierre 1 ]] (λz. (λe. λφ. x. (homme x) ( (λφ. (voit z x) (φ(push 2 x e)) (λe. T)))) (φ e))) [[Pierre 1 ]] (λz. (λe. λφ. x. (homme x) ( (voit z x) ( (λe. T) (push 2 x e)) ))) (φ e))) [[Pierre 1 ]] (λz. (λe. λφ. x. (homme x) ( ((voit z x) T)) (φ e) = (λψ.λe. λφ. (ψ pierre e (λe. φ(push 1 pierre e ))) (λz. (λe. λφ. x. (homme x) ( ((voit z x) T)) (φ e)) λe. λφ. ((λz. (λe. λφ. x. (homme x) ( ((voit z x) T)) (φ e)) pierre e (λe. φ(push 1 pierre e ))) λe. λφ. (λe. λφ. x. (homme x) ( ((voit pierre x) T)) (φ e)) e (λe. φ(push 1 pierre e ))) λe. λφ. (λφ. x. (homme x) ( ((voit pierre x) T)) (φ e)) (λe. φ(push 1 pierre e ))) λe. λφ. ( x. (homme x) ( ((voit pierre x) T)) (φ(push 1 pierre e)) = λe. λφ. ( x. ((homme x) (voit pierre x))) (φ(push 1 pierre e)) NB : on voit ici fonctionner les astuces suivantes : 1- le quantificateur tout n est pas traduit directement par une implication, puisque le connecteur ne vient pas du déterminant mais du nom commun homme et que ce connecteur est une conjonction, donc on écrit (p q) à la place de p q. 2- le fait que l indice introduit par tout ne soit plus accessible ensuite se traduit par un contexte droit λe. T, il est tel que lorsqu il est fait appel à ce contexte droit pour s appliquer à (push 2 x e), comme T est une constante, push 2 x e disparaît, et il ne reste dans le deuxième conjoint associé à (voit z x) que la constante T, interprétée 18

19 comme le «vrai», de sorte que ((voit z x) T)) soit tout simplement réductible à la négation du prédicat (voit z x). Autrement dit, le contexte droit ne pourra pas accéder à l indice 2 introduit ici avec tout. 3- Mais le futur contexte droit pourra accéder à l indice 1, associé à Pierre. De sorte évidemment qu une suite comme : Pierre voit tout homme. Il siffle, ne pourra s interpréter qu avec Il renvoyant à Pierre. Ceci dit, attention, il existe des cas d anaphore (en contexte intensionnel) où l accessibilité est rétablie. Cf : tout chat qui attrape une souris la mange. En général, il ne la fait pas souffrir (cf. Craige Roberts, 1996).??Le contexte droit devant, en ce cas, être intensionnel, il faudrait remplacer la fonction λe. T par une fonction plus complexe du genre λe. φ, qui nécessite que φ soit intensionnelle pour avoir φ = φ, et qui donne bien λe.φ si c est le cas, et donnerait T sinon?? [[tout i ]] = λn. λψ. λe. λφ. ( x. (n x e (λe. (ψ x (push i x e)(λe. T))))) (φ e) [[un i ]] = λn. λψ. λe. λφ. x (n x e (λe. (ψ x (push i x e) φ))) NB: toujours il pleut se traduit par : λw. pleut(w) au lieu de w pleut(w)? λe. λφ. ( x. (homme x) ( ((voit pierre x))) φ(push 1 pierre (push 2 x e)) si φ est intensionnelle, λe. λφ. ( x. (homme x) ( ((voit pierre x))) φ(push 1 pierre e) sinon 19