Sémantique « continuationnelle » un aperçu. Quest-ce quune continuation? Exemple : –calculer (n), puis ensuite f( (n)) f est « la continuation » de la.

Slides:



Advertisements
Présentations similaires
La boucle for : init7.c et init71.c
Advertisements

Déductions logiques et calcul de représentations sémantiques Alain Lecomte UMR SFL Séminaire « Logique, Sémantique, Dialogue » - partie I.
Fonctions & procédures
Termes préfixés et N-uplets
Approches formelles en syntaxe et sémantique Alain Lecomte UMR 7023 Structures Formelles de la Langue.
Approches formelles en syntaxe et sémantique Alain Lecomte UMR 7023 Structures Formelles de la Langue.
Système formel Nous avons introduit : signes de variables (x, y, z, …), de constantes (0, 1), d’opérations (+, ), de relations (=, ) Axiomes : ce sont.
We are taking the language L to be a way of computing expressions, a recursive definition of a set EXP. (i) a set of features (ii) principles for assembling.
Introduction : Compilation et Traduction
8. Les tableaux P. Costamagna – ISEN N1.
financiers (comptabilisation
Tests Programmation par contrats
Continuité Introduction Continuité Théorème des valeurs intermédiaires
Introduction à la programmation (420-PK2-SL) cours 12 Gestion des applications Technologie de linformation (LEA.BW)
OCaml - Les listes L3 MI.
Introduction : Compilation et Traduction
Expressions et assignations
Algèbre de Boole et les Boucles
Faculté I&C, Claude Petitpierre, André Maurer What is this ? (Quest ce que this ?)
Création d’un programme :
Sémantique axiomatique
Introduction à la conception de Bases de Données Relationnelles
IFT313 Introduction aux langages formels
Programmation linéaire
Optimisation linéaire
Le codage des nombres en informatique
Lambda-Calcul Sémantique de Montague
Programmation fonctionnelle Le langage LISP
Équations différentielles.
LL et modalités Conception inférentialiste des modalités (sans mondes possibles) Considérer les régimes dinférence propres aux connecteurs de base de LL.
CONSTRUCTION MECANIQUE DECOUVERTE de SOLIDWORKS
Les pointeurs Modes d’adressage de variables. Définition d’un pointeur. Opérateurs de base. Opérations élémentaires. Pointeurs et tableaux. Pointeurs et.
Rappels de logique des prédicats du 1er ordre
Semaine #1 INF130 par Frédérick Henri.
Points importants de la semaine Le préprocesseur. La conversion de types. Les fonctions.
Points importants de la semaine Les constantes de compilation. Les fonctions.
Programmation linéaire en nombres entiers Algorithme de la subdivision successive («Branch and Bound Algorithm»)
Les applications évoluées (traduction automatique) nécessitent beaucoup d'informations lexicales : délimitation des mots composés, lemmes... Cela fait.
Partie II Sémantique.
Sémantique dénotationnelle
Structures de données IFT-2000 Abder Alikacem La récursivité Semaine 5 Département dinformatique et de génie logiciel Édition Septembre 2009.
Modélisation des opérations Spécifier les transformations détat que lon attend des services de la machine Létat dune machine entièrement déterminée par.
Programmation linéaire en nombres entiers : les méthodes de troncature
Programmation procédurale Transformations
Programmation fonctionnelle Lambda-calcul
La Logique du premier ordre LPO
Sémantique logique 2- sémantique de Montague
Programmation linéaire en nombres entiers
Calcul parallèle => partitionner les données en sous-groupes associés aux processeurs. P0 P2 P1.
Cours C++ Fonctions Surcharge d’opérateurs Passage d’arguments
D.E ZEGOUR Ecole Supérieure d’Informatique. Problèmes de décision Concepts de base Expressions régulières Notation particulière pour exprimer certaines.
Le langage Racket (Lisp)
LES PRINCIPES DE LA THERMODYNAMIQUE
Structures de données avancées : LH (Hachage linéaire) D. E ZEGOUR Institut National d ’Informatique.
Introduction au langage C : Structures de contrôle 1 ère année Génie Informatique Dr Daouda Traoré Université de Ségou
Systèmes formels 1. Définition d'un SF Morphologie Théorie propre
Post-optimisation, analyse de sensibilité et paramétrage
Scripts et fonctions Instructions de contrôle
Une aide pour débutant éclairé
Chapitre 4 La représentation des nombres.
Algorithmique Tableaux de données
1 Initiation aux bases de données et à la programmation événementielle Cours N°8 : Gestion de la cohérence avec des zones de liste déroulantes. Souheib.
Algorithmique Boucles et Itérations
Les bascules et registres
Introduction à l’Informatique chap 3 Licence SPI Mme Delmotte.
Chap. 3 Récursion et induction. Les définitions par récurrence consistent à construire des objets finis, à partir d'autres, selon certaines règles. Les.
LES POSTULATS DE LA MÉCANIQUE QUANTIQUE
IFT359 – Programmation fonctionnelle Thème 07 Fermeture, affectation ou monades 1.
Transcription de la présentation:

Sémantique « continuationnelle » un aperçu

Quest-ce quune continuation? Exemple : –calculer (n), puis ensuite f( (n)) f est « la continuation » de la suite de calculs au moment où on termine avec, on ne sait pas ce qui vient après faire de « ce qui vient après » largument dune fonction -barre(n, f) = f( (n))

Continuation et types : a b f : b c -barre : a ((b c) c) cas particulier: c = -barre(n) : (b ) logique classique : (b ) b

Ex: sémantique de Montague Quantificateur tout : (e t) ((e t) t) tout chat : (e t) t initialement : SN de type e SN quantifié : de type (e t) t cest le « continuisé » de [[SN]]

SNSV SNSV fonctionArgument fonctionArgument

YX1 X2 X4 X3 Contextes successifs

utilités En programmation : –En cas derreur, sauver le calcul intermédiaire et effectuer une opération (envoi dun message) –Cf. GOTO (aller directement à une instruction de programme, ici cest comme si on donnait comme argument la suite dinstructions à partir dune certaine étiquette)

Exemple (define (produit L) (if (null ? L) 1 (* (car L)(produit (cdr L)))) Pas efficace (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

Introduire une variable de continuation (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))))))) (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 commentaire : partons de k = id, si la liste L nest pas vide et si son premier élément nest pas 0, alors on applique la fonction au cdr, avec comme valeur de k : p. p (car L), puis si (cdr L) nest pas vide et son premier élément nest pas 0, on applique la fonction au cdr du cdr mais cette fois avec comme valeur de k : p. ( p. p (car L) p (car (cdr L))) = p. (p (car (cdr L))) (car L) etc.

Fonctions qui manipulent les contextes Soit E = (… (call/cc (lambda(k) corps) …) Lappel de call/cc lie k à la continuation qui suit (call/cc (lambda(k) corps) dans E

exemple (call/cc (lambda (k)(+ 2 (* 7 (k 3))))) contexte : identité résultat : 3 (* 4 (+ (call/cc (lambda (k) (* 5 8))) 2)) contexte : (lambda ([])(* 4 (+ [] 2))) résultat : (* 4 (+ (* 5 8) 2)), soit : 168 (* 4 (+ (call/cc (lambda (k) (* (k 5) 8))) 2)) même contexte résultat : ((lambda ([])(* 4 (+ [] 2))) 5) 28

( * 4 (+ (call/cc (lambda (k) (* 5 8))) 2)) ( * 4 (+ (call/cc (lambda (k) (* (k 5) 8))) 2))

( * 4 (+ (call/cc (lambda (k) (* 5 8))) 2)) ( * 4 (+ (call/cc (lambda (k) (* (k 5) 8))) 2)) E[call/cc(M)] E[M( z.E[z])] M M E

((lambda ([])(* 4 (+ [] 2))) 5) ( * 4 (+ (* 5 8))) 2)) E[call/cc(M)] E[M( z.E[z])]

-calcul M. Parigot (1990) continuations goto étiquettes dinstructions point de vue logique : –étiquettes dinstructions formules nommées variables « pour nommer » : les -variables Si une -variable « sapplique » à un terme : elle nomme ce terme : –( t) : t est nommé par -abstraction : les termes nommés par deviennent actifs –( M)(N) : N est passé aux sous-termes de M nommés par

exemple ((( y.. ( (y x.. ( x))) u) a) b) ((. ( (u x.. ( x))) a) b)

exemple ((( y.. ( (y x.. ( x))) u) a) b) ((. ( (u x.. ( x))) a) b) (. ( (u x.. ( (x a)))) b)

exemple ((( y.. ( (y x.. ( x))) u) a) b) ((. ( (u x.. ( x))) a) b) (. ( (u x.. ( (x a)))) b). ( (u x.. ( ((x a) b)))) NB: Le fait que létiquette soit conservée fait que lon peut appliquer un tel -terme à une suite quelconque de termes : on nest pas obligé comme dans le -calcul standard de prévoir exactement le nombre de termes auquel on veut appliquer lopérateur.

intuition « The intuition for this term calculus is that each -sequent has exactly one active, or principal, formula, A, on the right-hand side, i-e., the leftmost one, which is the formula upon which all introduction and elimination rules operate » de Paiva & Ritter, 2005

Extension de Curry-Howard |- t : A, |- t :, A, |- ( t) :, A, |-. t : A, 1 ère règle : distinguer une formule et lui donner un nom, en même temps on « gèle » la formule car elle nest plus la première en partie droite 2 ème règle : repérer une formule daprès son étiquette et la rendre active, en même temps, on « dégèle » la formule car elle apparaît maintenant en tête de la partie droite à gauche : que des x : A – x une variable et A un type – à droite : que des A - un nom et A un type –

Interprétation de la négation |- t : A, |- t :, A, |- ( t) :, A, |-. t : A, |- t : A, A, |- t :,, A |- ( t) :,, |-. t : A, |- t : A, |- t : A, |- ( t) : A, |-. t : A, geler une formule = appliquer la double négation dégeler une formule = appliquer lélimination de la double négation

Règle déchange |- t : B, A, |-. ( t) : A, B, Règle « déchange » : rendre active A en gelant B

Exemple de déduction A |- A en logique classique A |- A |- A|- A, A |- A

Obtention dun -terme t : A |- t : A t : A |- ( t) :, A |- M : A|- t. ( t) : A, A |- M( t. ( t)) :, A |-. M( t. ( t)) : A

variations 1..M dans un contexte ([] N) : : ((.M) N).M[( t) := ( (t N))] 2..M dans un contexte (N []) : : (N (.M)).M[( t) := ( (N t))] en ce cas, il ny a plus la propriété de Church-Rosser

de Groote, 2001 Toute personne aime un chat Expressionsémantiquetype toute personne. x. personne(x) ( x) e un chat. y. chat(y) ( y) e aime x. y. ((aime y) x)e (e t)

Pourquoi « toute personne » de type e? (supposer t = ) |- personne: e tx : e |- x : ex : e |- x : e x : e |- personne(x) : tx : e |- ( x) : t, e x : e |- personne(x) ( x) : t, e |- x personne(x) ( x) : t, e |-. x personne(x) ( x) : e supposé de type e (t t) supposé de type t t

Différentes lectures 1- (( x. y. ((aime y) x). y. chat(y) ( y)). x. personne(x) ( x))

Différentes lectures 1- ( y. ((aime y). y. chat(y) ( y)). x. personne(x) ( x))

Différentes lectures 1- ((aime. x. personne(x) ( x) ). y. chat(y) ( y))

Différentes lectures 1- ((aime. x. personne(x) ( x) ). y. chat(y) ( y)) contexte (N [] )

Règle 1- ((. x. personne(x) ( (aime x)) ). y. chat(y) ( y))

contexte ([] N)

Règle 1-. x. personne(x) ( ((aime x) (. y. chat(y) ( y)))) contexte ([] N)

simplification 1- x. personne(x) ((aime x) (. y. chat(y) ( y)))

nouvelle application de 1- x. personne(x). y. chat(y) ( ((aime x) y))

nouvelle simplification 1- x. personne(x) y. chat(y) ((aime x) y)

Différentes lectures 2- ((. x. personne(x) ( (aime x)) ). y. chat(y) ( y)) contexte (N [] )

Règle 2- (. y. chat(y) ( (. x. personne(x) ( (aime x))) y))

simplification 2- y. chat(y) (. x. personne(x) ( (aime x))) y)

Règle 2- y. chat(y) (. x. personne(x) ( (aime x))) y)

Règle 2- y. chat(y) (. x. personne(x) ( ((aime x) y )))

simplification 2- y. chat(y) x. personne(x) ((aime x) y ))

((aime. x. personne(x) ( x) ). y. chat(y) ( y) ) N [ ]

((aime. x. personne(x) ( (aime x)) ). y. chat(y) ( y) )

(. x. personne(x) ( (aime x)). y. chat(y) ( y) )

(. x. personne(x) ( ((aime x). y. chat(y) ( y) )))

(. x. personne(x) ( (. y. chat(y) ( ((aime x) y) )))

x. personne(x) y. chat(y) (aime x) y)

(. x. personne(x) ( (aime x)). y. chat(y) ( y) )

(. y. chat(y) ( (. x. personne(x) ( (aime x)) y) )

y. chat(y) x. personne(x) ((aime x) y)

intérêt Absence de Quantifier-Raising Lobjet quantifié et le sujet quantifié sont traités de la même façon

Grammaires continuisées (Chris Barker) Transformations CPS –c de type e : c = k. k(c) de type, t> – x. M de type : x. M = k. k( x. M) de type, b*>, b*> où b* type de M –(M N) = k. (M ( m. N( n. (k (m n))))) Exemple – x. dort(x) de type – x. dort(x) = k. k( x. dort(x)) de type, t>, t>

exemple Pierre dort old: pierre x. dort(x) dort(pierre) new : u.u(pierre) k.k( x. dort(x)) u.u x. dort(x) dort(pierre)

exemple Pierre dort old: pierre x. dort(x) dort(pierre) new : u.u(pierre) k.k( x. dort(x)) u.u x. dort(x) dort(pierre) Continuation 1

exemple Pierre dort old: pierre x. dort(x) dort(pierre) new : u.u(pierre) k.k( x. dort(x)) u.u x. dort(x) dort(pierre) Continuation 1 Continuation 2

Schèmes de continuation 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 lopération qui relie a, b et c, ici lapplication, 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)))))))

application S SN SV u. [[SV]]* ( P. [[SN]]* ( x. u (P x)))ou u. [[SN]]* ( x. [[SV]]* ( P. u (P x))) où [[X]]* est la continuisation de la sémantique de X Même résultat que de Groote, 2001

Continuisations et DRT daprès de Groote 2005 Problèmes avec DRT: –La fusion de deux DRS peut conduire à des assignations de valeurs qui détruisent les valeurs précédemment assignées –pour léviter: procéder à des renommages astucieux… dans ce qui suit, on ne recourt pas à des variables

Continuisations et DRT daprès de Groote 2005 Un énoncé sinterprète en contexte contexte gauche : g contexte droite : g t énoncé : g ((g t) t)

discours D D E But : trouver la bonne contrepartie sémantique de cette règle –soit e une variable de contexte gauche –soit une variable de contexte droite e.. ([[D]] e ( e.([[E]] e, ))) : Quel lien entre e et e ? D D E ee

DRS [[x 1, …, x n ] ; C 1, …, C m ] x 1, …, x n C 1 … C m Version continuisée: e.. x 1, …, x n C 1 … C m (, e) où e dépend (comment?) de e, x 1, …, x n et est une continuation (« droite ») qui sapplique au nouveau contexte gauche fourni par e x 1, …, x n C 1 … C m e e

exemple John 1 loves Mary 2. He 1 smiles at her 2 désormais: –[[np]] = g ((g (e t)) t) deux cas : –Nom propre : introduit un nouvel indice dans le contexte gauche qui sera utilisé par la continuation (push) –Pronom : sélectionne un indice dans le contexte gaucje (select) NPVP g g (e t) t

push prend pour argument un entier lui associe une fonction qui : –à un objet de type e associe –une fonction de changement de contexte Type : N (e (g g))

select prend en argument un entier lui associe la fonction qui –Au contexte gauche existant associe lobjet de type e qui correspond à cet entier Type : N (g e) select i ( push j a l) = a si i = j = select i l, sinon

Nom propre indicé [[John i ]] = e.. ( (push i john e) john) contexte gauche old continuation Rappel : –[[np]] = g ((g (e t)) t) contexte gauche new e

Pronom indicé [[he i ]] = e.. ( e ( select i e))

Verbe transitif [[np]] ([[np]] [[s]]) (g ((g (e t)) t)) ((g ((g (e t)) t)) (g ((g t) t)))) o. s. e.. (s e ( e. x. (o e ( e. y. (love x y) ( e)))))

dérivation (( 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)) e.. ((love john mary) ( ( push 2 mary (push 1 john e))))

… he smiles at her ! cf. e.. ([[D]] e ( e.([[S]] e, ))) pour composer les deux parties avec he smiles at her : e.. (smile (select 1 e)(select 2 e) ( e))

dérivation 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)))

prolongements Eviter: Every man loves a woman. *He smiles at her Pour cela : –Prendre à égalité de traitement contextes gauche et droit –Au lieu de [[Mary i ]] = e.. ( ( push i mary e) mary) [[Marie i ]]=. e.. ( marie e ( e. ( push i marie e))) individu contexte gauche contexte droit contexte gauche individu