. !Γ,print,A⊢∆ & gauche 1 !Γ,print,A&C ⊢∆ (3) !Γ,C,A&C ⊢ ∆ (4) !Γ,C,D⊢∆ ⊗gauche !Γ,C⊗D⊢∆ (2) !Γ,B⊢∆ (1) !Γ,A⊢∆
Plusieurs remarques peuvent être faites sur cette arbre d’exécution. L’opérateur⊗correspond
bien à l’exécution parallèle. Il crée deux hypothèses linéaires distinctes qui seront ensuite explo-rées de manière indépendante. L’ordre d’exploration dans la preuve est donc a priori inconnu, de même que l’ordre d’exécution de deux fils d’exécutions. Dans ce cas, il est possible qu’on
explore d’abord l’hypothèseCpuis l’hypothèseDou inversement.
Pour l’opérateur &, on peut voir qu’on doit explicitement choisir une des deux hypothèses. Ici, on a choisi l’hypothèse à gauche. Le choix de l’hypothèse sélectionnée dépend de
l’environ-nement !Γet n’est donc pas aléatoire (bien que non explicité ici). Il permet ainsi d’exprimer la
notion de choix.
Nous utilisons ici les règles à gauche du séquent. Ce sont donc le dual des règles à droite explicités précédemment, via les règles de Morgan. Si par exemple, on considère le contexte
A ⊗ B ⊢ ∆, on peut passer les arguments à droite en prenant leur négation soit le séquent ⊢
∆,A⊥ `B⊥. On applique ensuite la règle à droite pour `soit ⊢ ∆,A⊥,B⊥ puis on repasse les
arguments à gaucheA,B⊢∆.
7.2 Schémas généraux de la modélisation
Après cette introduction à la logique linéaire et son utilisation pour décrire l’exécution concur-rente, nous allons maintenant nous intéresser plus précisément à la façon dont nous pouvons
modéliser roar en utilisant ces principes. Nous commençons d’abord par la modélisation de
7.2. SCHÉMAS GÉNÉRAUX DE LA MODÉLISATION 99
7.2.1 Passage par destination
Pour encoder la sémantique opérationnelle de roar, nous allons utiliser une représentation
par destination, proposée entre autre par (Cervesato et al., 2003) pour encoder la sémantique du langage ML (Milner, 1997). Cette représentation permet une représentation plus modulaire et moins complexe que les approches classiques par continuation ou contexte d’évaluation.
Concrè-tement, pour chaque calcul, on va créer une “destination”, i.e.une variable unique partagée par
le processus calculant et le processus demandant qui servira de passage entre ces deux contextes.
Plus formellement, on commence par introduire pour tout type T, val T qui représente une
valeur de typeT, exp T une expression retournant un typeT, etdest T une destination de type
T. On peut alors introduire les deux formules eval (E D) qui évalue l’expression E de type
exp T dans D de type dest T et return (V D) qui retourne la valeur V de type val T depuis
une destination dest T. De manière informelle, sans considérer d’effets spécifiques, si l’on a
l’hypothèse linéaireeval(E D), alors il existe une hypothèse linéairereturn(V D) si et seulement
si l’évaluation deEconduit au résultatV.
Nous allons montrer comment utiliser cette représentation pour évaluer des expressions plus complexes.
7.2.2 Exécution séquentielle
Commençons par l’exécution séquentielle,i.e. y= f(x);z = g(y); Dans notre cadre logique,
nous notons cela llet F(λx.G(x)). L’évaluation d’une telle expression peut alors se faire de la
façon suivante :
eval_llet :eval(llet F (λx.Gx)D)
⊸ ∃d1 :dest T.(eval(F d1)
⊗(∀V1 :val T.return(V1d1)⊸eval((G V1)D))).
L’arbre d’exécution associé serait alors :
!Γ,return((V2)D))⊢∆
..
. (3)
!Γ,eval((G V1)D))⊢∆
⊸(2) !Γ,return(V1d1),(return(V1d1)⊸eval((G V1)D))⊢ ∆
∀
!Γ,return(V1d1),(∀V.return(V d1)⊸eval((G V)D))⊢∆
..
. (1)
!Γ,eval(F d1),(∀V.return(V d1)⊸ eval((G V)D))⊢ ∆
⊗
!Γ,eval(F d1)⊗(∀V.return(V d1)⊸eval((G V)D)))⊢ ∆
∃
!Γ,∃d.(eval(F d)⊗(∀V.return(V d)⊸eval((G V)D))⊢ ∆)
⊸
!Γ,eval(llet F(λx.Gx)D)⊢∆
Pour voir que cela correspond bien à une exécution séquentielle, il faut noter qu’on ne peut
le contexte linéaire (ce qui est réalisé en (1)). Ainsi, l’hypothèse de droite ne peut être explorée
qu’après l’hypothèse de gauche, i.e. l’exécution de G doit attendre que l’exécution de F soit
terminée. L’autre point intéressant est que l’utilisation de l’opérateur ⊸ consomme la formule
return(V1 d1) qui ne pourra donc plus être réutilisée.
7.2.3 Les entiers naturels et autres structures de base
Une telle modélisation n’est pour l’instant pas tellement utile, étant donné qu’on peut re-présenter des processus, mais pas particulièrement de données. Nous allons maintenant
expli-quer comment on peut représenter les entiers naturels. On définit le type nat, et deux formules
pour le construire, z pour zéro et scomme successeur. On peut ainsi noter le chiffre 4 comme
(s(s(s(s z)))). On peut alors implémenter les différents algorithmes classiques, sur les entiers.
Par exemple, l’addition pourrait s’écrire ainsi :
eval_add :eval((add M N)D)
⊸∃d:dest nat.(eval(M d)
⊗(return(z d)⊸return(N D)
& (∀M′ :val nat.return((s M′)d). ⊸eval(add M′ s(N)D)))).
Évaluons le début d’arbre d’exécution associé pour l’addition pour M=1 et N=2.
.. .
!Γ,eval((add z s(N)D))⊢∆
⊸
!Γ,return(s z d1),(return(s z d1)⊸eval((add z s(N)D))⊢∆
∀
!Γ,return(s z d1),(∀M′.return(s M′d1)⊸eval((add M′s(N)D))⊢∆
& !Γ,return(s z d1),(return(z d1)⊸return(N D)) & (∀M′.return(s M′d1)⊸eval((add M′s(N)D))⊢∆
!Γ,eval(F d1),(return(z d1)⊸return(N D)) & (∀M′.return(s M′d1)⊸eval((add M′s(N)D))⊢∆
⊗
!Γ,eval(F d1)⊗(return(z d1)⊸return(N D)) & (∀M′.return(s M′d1)⊸eval((add M′s(N)D))⊢∆
∃
!Γ,∃d.(eval(F d)⊗(return(z d)⊸return(N D)) & (∀M′.return(s M′d)⊸eval((add M′s(N)D)))⊢∆
⊸
!Γ,eval(add M N)))D)⊢∆
On a donc à faire à une règle récursive. L’évaluation que l’on a présentée s’arrête à l’appel
récursif avec M’= 0 et N’ = 3. L’évaluation suivante utilise alors le séquent ⊢ return(z d) ⊸
return(N D), qui termine l’évaluation. L’utilisation de l’opérateur & dénote bien du choix : on
explore l’un ou l’autre des séquents en fonction de la valeur contenue dans la destinationd1.
On peut construire de la même façon les différents opérateurs sur les entiers, par exemple
l’opérateur<=ci-dessous (on suppose l’existence d’un type bool avec les formules de base True
et False).. Dans la suite, on utilisera donc les notions classiques d’entiers et d’opérateurs pour ne pas surcharger les modélisations.
7.2. SCHÉMAS GÉNÉRAUX DE LA MODÉLISATION 101
eval_less_eq:eval((less_eq M N)D)
⊸∃d1:dest nat.eval(M d1)
⊗(return(z d1)⊸return(T rue D) & (∀V1 :val nat.return((s V1)d1)
⊸∃d2:dest nat.eval(N d2)
⊗(return(z d2)⊸return(False D) & (∀V2 :val nat.return((s V2)d2)
⊸eval((less_eq V1V2)D)))).
De manière plus générale, on peut définir toutes les structures inductives, en particulier les listes, les chaînes de caractères, . . . La aussi, si nécessaire, on utilisera les notations standards
pour ne pas alourdir la présentation des modèles. En particulier, on utilisera nil pour
déno-ter de la liste vide et cons pour le constructeur de la liste : la liste [1, 2, 3] sera donc notée
(cons1 (cons2 (cons3nil))).
7.2.4 Références
Chaque agent contient un certain nombres de variables (son contexte) représentant son état.
Les valeurs de ces variables changent au cours de temps, ce qui est généralement difficile à
mo-déliser en logique classique. Traditionnellement, on utilise la notion de “référence” pour désigner ces variables mutables. La modélisation que nous en faisons passe par l’utilisation de cellules,
i.e.des cases mémoires qui servent à stocker la valeur de la référence. Ainsi, la variable cellule
reste constante, mais le contenu associé à cette cellule change (de la même façon qu’un pointeur).
Plus formellement, on définit les nouveaux types re f T qui désigne une référence sur une
variable de typeT, et cell T une cellule qui contient une donnée de type T. On pose alors les
formules suivantes :
– contains(C V) signifie que la celluleCcontient la valeurV. – cell Ccrée une référence à partir d’une cellule.
– newre f E crée une référence et lui associe le résultat de l’évaluation deE.
– assign (E1 E2) modifie la valeur de la référence représentée par l’expression E1 par le
résultat de l’évaluation deE2.
eval_newre f :eval((newrefE1)D)
⊸∃d1:dest T.eval(E1d1)
⊗(∀V1:val T.return(V1d1)
⊸∃c:dest T.contains(c V1)⊗return((cell c)D)).
eval_assign:eval((assign(E1 E2))D)
⊸∃d1:dest(re f T).eval(E1d1)
⊗(∀C1:dest T.return((cell C1)d1)
⊸∃d2 :dest T.eval(E2d2)
⊗(∀V2 :val T.return(V2 d2)
⊸∀V1 :val T.contains(C1 V1)
⊸ contains(C1V2)⊗return((void′)D))).
eval_dere f :eval((dere f E1)D)
⊸∃d1:dest T.eval(E1d1)
⊗(∀C1:dest T.return((cell C1)d1)
⊸∀V1 :val T.contains(C1V1)
⊸contains(C1 V1)⊗return V1 D).
L’encodage deeval_newre f ne comporte rien de particulier. Dans un premier temps, on
cal-cule la valeur de l’expressionE1 puis on crée une nouvelle cellule avec l’opérateur∃. On ajoute
alors les faitscontains(C v) etreturn((cellc)D) et on termine l’évaluation. Le cas deeval_assign
est un peu plus intéressant. On calcule d’abord la valeur de l’expressionE1 puis la référence
re-présentée par la valeur E2. Dans un second temps, on consomme grâce à l’opérateur ⊸ le fait
contains (C1 V1) pour la remplacer par le fait contains (C1 V2). Ainsi, grâce à l’implication linéaire, on garantit qu’une cellule ne peut contenir qu’une seule et unique valeur au même
mo-ment. La modélisation deeval_dere f utilise le même principe : on remet ici explicitement le fait
contains(C1 V1) dans le contexte linéaire pour une réutilisation ultérieure de la référence.
7.2.5 Échanges de messages
Les différents agents communiquent via un ensemble de messages asynchrones. Pour
modé-liser cette communication, nous utilisons une représentation assez proche de celle des références.
On identifie des canaux de communications de typechan T permettant d’envoyer des messages
de type T. La formulemsg Ch M signifie que le canal de communicationChcontient un
mes-sage de valeur M (il est donc relativement analogue à contains). On définit alors les formules
suivantes :
– writeM sg(E1E2) prend en paramètre une expression E1représentant un canal de
commu-nication, et envoie le résultat de l’expressionE2 dans ce canal.
– readM sg E1 prend en paramètre une expression E1 représentant un canal de communi-cation, et renvoie la valeur du message qu’il contient (en attendant jusqu’à ce qu’il se
7.3. MODÉLISATION DE L’ASPECT LOGIQUE 103