manuscrit (PDF)

manuscrit (PDF)
THÈSE
présentée à l’École Normale Supérieure de Cachan
pour obtenir le grade de
Docteur de l’École Normale Supérieure de Cachan
par :
Spécialité :
Nathalie Sznajder
Informatique
Synthèse de systèmes distribués ouverts
Soutenue le 12 novembre 2009, devant un jury composé de :
–
–
–
–
–
–
Ahmed Bouajjani
Paul Gastin
Claude Jard
Jean-François Raskin
Igor Walukiewicz
Marc Zeitoun
président du jury
directeur de thèse
examinateur
rapporteur
rapporteur
examinateur
Résumé
Cette thèse est un travail sur la synthèse de systèmes distribués ouverts. Dans le problème
de synthèse, on considère un système en interaction avec un environnement incontrôlable,
et on se donne une description formelle de ses comportements corrects (la spécification). On
cherche alors à dériver automatiquement un programme pour le système dont toutes les exécutions satisfont la spécification et ce, quelle que soit la façon dont l’environnement se comporte.
Pour le problème de synthèse de systèmes distribués, on se donne en plus de la spécification
une description des communications possibles entre les différents processus du système, ainsi
que des communications entre l’environnement et les processus (l’architecture). Le but est
alors de synthétiser automatiquement un programme pour chaque processus du système. Ce
dernier problème est indécidable en général, et le travail effectué au cours de cette thèse vise
à comprendre les principales causes d’indécidabilité afin de proposer les restrictions les plus
naturelles possibles sous lesquelles le problème serait décidable. On choisit en particulier de se
restreindre aux spécifications de type externe, c’est-à-dire ne restreignant que les interactions
entre le système et l’environnement, en laissant non spécifiées les interactions entre les processus eux-mêmes. Dans un premier chapitre, on définit un modèle général présentant de manière
uniforme les différents résultats de la littérature sur le sujet, qui étaient exprimés dans des
formalismes divers. Ensuite on expose les résultats obtenus dans le cas de systèmes distribués synchrones. On propose une condition nécessaire sur l’architecture des systèmes pour
la décidabilité de ce problème, puis on définit une classe d’architectures (les architectures
uniformément bien connectées), pour laquelle cette condition devient un critère nécessaire et
suffisant. Finalement, on essaie d’étendre cette classe en définissant la classe des architectures
bien connectées, et on montre que le critère établi n’est plus une condition suffisante pour la
décidabilité du problème sur cette classe plus large. La preuve d’indécidabilité apporte des
éléments nouveaux sur les causes d’indécidabilité, permettant d’améliorer la compréhension
du problème. Le dernier chapitre présente les travaux effectués dans le cas de systèmes ayant
un comportement asynchrone. On introduit un nouveau modèle de communication : la communication par signaux ; un signal est une action commune à deux processus, mais qui n’est
contrôlée que par un seul. On s’intéresse à des spécifications externes portant sur des ordres
partiels, et on définit des propriétés de clôture que les spécifications doivent respecter. On
montre que dans ce cadre le problème est décidable pour tous les systèmes dont le graphe de
communication est fortement connexe.
Abstract
We study the synthesis problem for distributed open systems. Synthesis problems consists
in, given a formal description of correct behaviors of a system interacting with an uncontrollable environment (the specification), automatically deriving a program for this system
such that all its behaviors meet the specification, regardless how the environment behaves. In
synthesis of distributed systems, one is given along with the specification, a description of the
communications between the different processes of the system, and of the communications
between the processes and the environment (the architecture). The goal is in that case to
produce a program for each process. In general this last problem is undecidable. The work
presented here aims at clarifying the causes of undecidability, in order to define the most
natural restrictions leading to decidable subclasses of the problem. We consider in particular
external specifications, i.e., that constrain only communications between the system and the
environment, while communications between the different processes of the architecture are left
unrestricted. In a first chapter, we define a model for the synthesis problem for distributed
systems allowing to present in a uniform setting the different results of the litterature. Then
we give the results obtained for synchronous distribued systems. We determine a necessary
condition on the shape of the architectures for decidability, and we introduce a class of systems
(uniformly well connected architectures), for which this condition becomes a necessary and
sufficient criterion. Finally, we introduce the larger class of well connected architectures, and
we show that our criterion is not anymore a sufficient condition for this class. The undecidability proof gives new insights on the causes of undecidability, letting us to better understand
the problem. The last chapter presents the work done on asynchronous systems. We define
a new model of communication : communications by signals ; a signal is a common action
between two processes, but initiated by only one of them. We consider external specifications
over partial orders, and also ask for some closure properties for the specifications. We then
show that this setting gives decidability results for the class of systems where communication
happens through a strongly connected graph.
v
Remerciements
Je tiens à remercier Ahmed Bouajjani, Claude Jard et Marc Zeitoun d’avoir accepté de
faire partie de mon jury de thèse, ainsi que Jean-François Raskin et Igor Walukiewicz de
m’avoir faire l’honneur d’être rapporteurs. Marc a par ailleurs accepté de co-encadrer mon
stage de Master 2, et j’ai ainsi pu bénéficier de sa gentillesse et de ses explications éclairantes
durant sa dernière année à Paris. Par dessus tout je voudrais remercier très sincèrement Paul
Gastin pour son encadrement au cours de ces premières années de recherche. Sa rigueur et
sa pédagogie (ainsi que sa louable patience !) ont été pour moi des guides précieux. J’espère
avoir un peu appris ces qualités-là. Je le remercie également d’avoir toujours su dégager du
temps lorsque j’en ai eu besoin.
J’ai eu la chance de passer ces années de thèse au LSV. L’atmosphère familiale qui règne
dans ce laboratoire associée à un réel souci d’excellence ont été un moteur pour moi. J’ai ainsi
pu côtoyer un grand nombre de personnalités d’exception, que je ne pourrais pas toutes citer
– à croire que le recrutement se fait autant sur les qualités humaines que sur les performances
scientifiques. Je vais tout de même remercier Nico pour ses aides répétées en LATEX. Ce
document lui doit beaucoup ! Je remercie également Thomas Brihaye qui lors de son très
sympathique passage à Cachan m’a initiée un peu aux habitudes belges. Aujourd’hui je ne
suis pas déroutée lorsqu’on me parle de Louis, ou qu’un chauffeur me dit qu’il ne sait pas
entrer dans ce garage ; je pense aussi à Louis lorsque j’hésite devant mes cinq poubelles de tri :
où jeter ce plastique qui ne porte pas de numéro ? ? Je remercie également Benedikt pour les
instants Kinder (avec la participation de Peter, qui poussait la tentation jusqu’à me les déposer
sur mon bureau). Merci à Nathalie et Marie pour avoir partagé mes obsessions culinaires, et
patiemment écouté mes angoisses et déboires de thésarde (Arnaud en a aussi pris sa part). Je
remercie également ceux qui ont partagé mon bureau pendant ces années : Stéphanie (arriver
avant elle le matin a été un challenge que j’ai rarement relevé), Vincent Bernat, Régis, Antoine,
Arnaud et Najla. Un merci particulier à Vincent pour son aide technique, et à Antoine pour
avoir écouté avec autant d’enthousiasme le récit quotidien des péripéties de Betsalel.
Je remercie enfin, et comme c’est la tradition, ma famille pour son soutien. Ma mère et
ma belle-mère en particulier (dites « les grands-mères »), ont fait preuve d’un dévouement
sans faille pendant la rédaction de ce manuscrit, et ont donné beaucoup de leur temps, de leur
amour et de leur énergie à Betsalel, puis à Noa. Pour cela, je les remercie du fond du cœur.
Mes derniers remerciements vont à Vincent, pour sa vaillance, et pour m’avoir tant apporté
ces dernières années.
vi
Table des matières
1 Introduction
1
2 Formalismes
1
Définitions utiles . . . . . . . . . . . .
1.1
Modèles . . . . . . . . . . . . .
1.2
Logiques temporelles . . . . . .
1.3
Automates finis . . . . . . . . .
2
Le problème de synthèse et de contrôle
2.1
Cadre général . . . . . . . . . .
2.2
Comportement synchrone . . .
2.3
Comportement asynchrone . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
distribués
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Synthèse de systèmes synchrones
1
Le modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
Architectures à information incomparable . . . . . . . . . . . . . . . . .
3
Architectures uniformément bien connectées . . . . . . . . . . . . . . . .
3.1
Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2
Décider la connexion uniforme . . . . . . . . . . . . . . . . . . .
3.3
Le problème de SSD synchrone pour les architectures UWC . . .
3.4
Architectures UWC et spécifications robustes . . . . . . . . . . .
4
Architectures bien connectées . . . . . . . . . . . . . . . . . . . . . . . .
4.1
Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2
Architecture à information linéairement préordonnée indécidable
5
Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4 Synthèse de systèmes asynchrones
1
Le modèle . . . . . . . . . . . . . . . . . . .
1.1
Le système . . . . . . . . . . . . . .
1.2
Les spécifications . . . . . . . . . . .
2
Résultats de décidabilité . . . . . . . . . . .
2.1
Les structures singleton . . . . . . .
2.2
Les architectures fortement connexes
3
Bilan . . . . . . . . . . . . . . . . . . . . . .
vii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
9
9
12
15
17
17
24
38
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
51
52
64
74
74
75
83
88
89
90
91
97
.
.
.
.
.
.
.
101
. 102
. 102
. 109
. 116
. 116
. 126
. 143
.
.
.
.
.
.
.
.
viii
TABLE DES MATIÈRES
5 Conclusion
145
1
Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
2
Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Chapitre 1
Introduction
Vérification de programmes
Alors que les systèmes informatiques ont pris une place aussi prépondérante dans la vie
moderne, les conséquences tant économiques qu’humaines de défaillances de ces applications
sont devenues de plus en plus importantes. Il est donc crucial d’être capable de s’assurer de
leur bon fonctionnement. La méthode de vérification la plus immédiate consiste en fournir un
jeu de tests au programme à vérifier, et à confronter les résultats obtenus à ceux attendus.
Cette technique permet de mettre en évidence certaines erreurs, mais présente de sérieux
défauts ; tout d’abord, l’ensemble de tests effectués peut ne pas être exhaustif, c’est-à-dire
qu’il peut rester des exécutions erronées qui n’ont pas été détectées. De plus, les objectifs à
vérifier peuvent être donnés de façon imprécise et donner lieu à des erreurs d’interprétation. Il
convient donc de développer des méthodes plus fiables et plus rigoureuses permettant de s’assurer du bon fonctionnement d’un programme. Démontrer des propriétés sur des programmes
est un objectif essentiel de l’informatique moderne, mais n’est pourtant pas récent, et n’est
pas uniquement lié aux enjeux actuels. Dès 1953, [Ric53] a montré qu’il est impossible de
prouver automatiquement toute propriété non triviale sur un programme. Dès lors, la quête
de programmes automatiquement certifiés comme étant corrects semble vouée à l’échec. Cependant, il est possible d’espérer trouver des solutions partielles permettant de vérifier les
programmes. Les méthodes formelles font partie des approches proposées dans ce sens durant
les dernières décennies. Parmi elles, on distingue notamment
– la génération automatique de tests, qui, se basant sur une description formelle des comportements souhaités du système, génère un ensemble exhaustif de tests à effectuer.
Cependant il n’est pas toujours possible de fournir un tel ensemble de tests.
– la démonstration automatique, qui laisse l’ordinateur prouver automatiquement des
théorèmes décrivant les propriétés du système, en se basant sur la description du programme, et sur un ensemble de règles de déduction et d’axiomes. Cette méthode n’est
cependant pas totalement automatisable, et l’assistant de preuves a besoin d’être plus
ou moins guidé par une aide humaine pendant le processus.
– le Model-checking, méthode qui part, elle, d’une représentation abstraite du programme,
et d’une spécification formelle des comportements souhaités, et qui vérifie de façon
exhaustive que tous les comportements du modèle satisfont cette spécification. Bien
sûr, la recherche n’est exhaustive que sur l’abstraction du système considérée, et cette
méthode peut nécessiter d’être utilisée itérativement, après des raffinements successifs.
1
2
Chapitre 1. Introduction
Si la notion classique de programme est capturée par le modèle des machines de Turing
(une fonction qui prend une donnée en entrée, effectue un calcul dessus, et produit une sortie),
il existe de nombreux programmes qui n’ont pas ce type de comportements. Il s’agit de systèmes qui maintiennent une interaction permanente avec un environnement, en réagissant aux
actions de ce dernier (l’environnement peut modéliser aussi bien un autre programme, qu’un
composant physique en interaction avec le système, ou encore un utilisateur humain). On appellera de tels programmes (modélisant par exemple des systèmes d’exploitation) des systèmes
réactifs, par opposition aux premiers que l’on appellera programmes transformationnels. Les
spécifications sur de tels systèmes décrivent des séquences éventuellement infinies d’événements. Le formalisme logique le plus largement utilisé par la communauté scientifique pour
la description des comportements de ce type de systèmes est celui des logiques temporelles,
introduites dans le monde de la vérification par [Pnu77]. Les logiques temporelles se divisent
en deux « familles », correspondant à deux représentations du temps. Dans la première on
trouve les logiques de temps linéaire (dont la plus célèbre est LTL), qui supposent l’exécution
du système fixée dès le départ. Les modalités utilisées concernent alors l’unique futur possible
dans l’exécution sélectionnée. Dans la seconde sont regroupées les logiques de temps arborescent (CTL, CTL∗ ,. . . ). Dans ce cas, on estime qu’à chaque instant de l’exécution plusieurs
futurs sont envisageables, et on permet donc d’exprimer des contraintes sur l’existence d’un
prolongement possible de l’exécution courante. Le Model-checking décrit ci-dessus, avec des
spécifications décrites par des formules de logique temporelle, s’est révélé particulièrement
populaire pour la vérification de tels systèmes.
Synthèse et contrôle de systèmes
Un des reproches qui a cependant été fait à ces techniques de vérification est qu’elles
interviennent uniquement à la fin du processus de développement, une fois qu’une quantité
importante de ressources a été investie dans le programme. Il serait intéressant de pouvoir
dériver automatiquement un programme, directement à partir de sa spécification. Lorsque
le système interagit avec un environnement, le problème est essentiellement de savoir s’il est
possible de déterminer, étant donné une description des comportements que l’on souhaite, s’il
existe un programme dont toutes les exécutions satisfont la spécification et ce, quel que soit la
façon dont se comporte l’environnement. Il s’agit de synthèse de systèmes ouverts. La question
a été posée pour la première fois par Church [Chu63], et concernait la synthèse de circuits, et
des spécifications données dans la logique monadique du second ordre sur les mots MSO. La
réponse a été apportée par Büchi et Landweber [BL69], qui ont montré que le problème était
décidable, en utilisant des techniques issues de la théorie des jeux. En effet, la synthèse de
systèmes réactifs peut être vue comme un jeu entre l’environnement et le système, dans lequel
la condition de gain est la spécification. Lorsqu’une partie satisfait la spécification, le système
gagne, sinon c’est l’environnement. Ainsi, fournir une stratégie gagnante pour le système
revient à donner une description du programme capable de satisfaire la spécification quel que
soit le comportement de l’environnement au cours de l’exécution. De plus, si on peut construire
une stratégie à mémoire finie, elle correspond à un programme à états finis pour le système.
Quelques années plus tard, une autre démonstration, plus simple, a été apportée par [Rab72],
basée sur la remarque que même si la spécification porte sur des exécutions vues comme des
mots, la nécessité de considérer tous les comportements possibles de l’environnement induit un
branchement qui impose d’utiliser des automates sur les arbres afin de résoudre le problème.
3
Le problème de l’existence d’un programme satisfaisant une spécification donnée sur toutes
ses exécutions est appelé le problème de réalisabilité. Si la réponse est positive, produire un
tel programme est le problème de synthèse.
Dans leurs formes modernes, les problèmes de réalisabilité et de synthèse ont été étudiés
dans les années suivantes, sous diverses variantes. La synthèse de programmes transformationnels a été traitée par [MW80], puis celle de systèmes réactifs clos (i.e., qui n’interagissent
pas avec un environnement incontrôlable, comme dans le cas de systèmes ouverts) devant
satisfaire des spécifications données en logique temporelle a été résolue par [EC82, MW84].
La synthèse de systèmes réactifs ouverts (comme celle considérée par [Chu63, BL69]) a été
à nouveau considérée par [ALW89, PR89a]. En particulier, les travaux de [PR89a] résolvent
le problème de synthèse pour des spécifications de la logique temporelle LTL, et donnent un
algorithme bien plus simple que dans le cas général de la logique monadique du second ordre.
Le travail de cette thèse se place dans le cadre des systèmes réactifs ouverts.
À la fin des années 1980 a été égalemment développée la théorie du contrôle des systèmes à
événements discrets [RW89]. Les systèmes à événements discrets (DES) sont des systèmes de
transition dans lesquels le changement d’état est déclenché par l’occurence d’un événement.
Dans le problème de contrôle, on se donne un programme (modélisé par un DES) en interaction
avec l’environnement, et une spécification, mais, contrairement au problème de la vérification
que l’on a évoqué plus haut, le but n’est pas de s’assurer que le programme satisfait la
spécification, mais de le forcer à la satisfaire, i.e., de restreindre ses comportements possibles.
Ceci se fait par l’intermédiaire d’un contrôleur, modélisé également par un DES, qui va évoluer
en parallèle avec le système à contrôler (on dit aussi à superviser), en le contraignant à
rester dans l’ensemble des comportements autorisés par la spécification. Dans ce modèle, les
événements du système à contrôler sont partitionnés entre les événements contrôlables, et les
événements incontrôlables. Le contrôleur à synthétiser n’est bien sûr autorisé à restreindre
que les actions contrôlables du système, et ne doit pas interdire toutes les actions contrôlables
(dans ce dernier cas, le problème deviendrait trivial : l’ensemble des comportements possibles
du système étant vide, il est toujours inclus dans l’ensemble des comportements acceptés
par la spécification !). Le cadre de la théorie des jeux reste très utile pour ce problème (voir
[AVW03], dans lequel ont été considérées des spécifications du µ-calcul). Des contrôleurs
pour des spécifications données dans une logique de temps arborescent ont également été
étudiés dans [MT02a], où les contrôleurs assurent la bisimilarité du système supervisé et de
la spécification.
En fait, le problème de synthèse de Church et le problème de contrôle de RamadgeWonham sont extrêmement proches conceptuellement, et l’on peut voir le problème de synthèse comme un cas particulier du problème de contrôle : celui dans lequel le système à
superviser est constitué d’un unique état, à partir duquel toutes les actions sont possibles.
Les travaux cités jusqu’à présent se concentraient sur des systèmes centralisés. Or, les
applications réelles impliquent de plus en plus des systèmes distribués, c’est-à-dire constitués
de plusieurs processus, pouvant communiquer entre eux de manière plus ou moins restreinte
(cet ensemble de processus et leurs possibilités de communication étant décrits par une architecture). Étendre les résultats sur la synthèse et le contrôle de systèmes réactifs ouverts
aux systèmes distribués constitue donc un objectif important. Ce problème est plus difficile,
puisque dans ce cas, les différents processus formant le système ont chacun une vue partielle de
l’état global, obtenue en rassemblant les informations reçues localement de l’environnement,
et celles obtenues par communication avec les autres processus. Une première étape dans
la résolution de ce problème est de considérer des systèmes centralisés, mais à information
4
Chapitre 1. Introduction
partielle. Dans de tels systèmes, on considère que certaines informations de l’environnement
sont cachées au contrôleur (ou simplement au processus du système dans le cas de la synthèse), qui doit cependant réussir à satisfaire la spécification. Ce problème a été abordé dans
[KV97, KV99, AVW03], pour des spécifications en logique de temps arborescent. Pour les systèmes distribués se pose par ailleurs la question de la sémantique d’exécution : synchrone ou
asynchrone. Dans les systèmes à exécution synchrone, une horloge globale règle l’avancement
de tous les processus, et chaque processus, ainsi que l’environnement, effectue une action à
chaque instant donné par l’horloge. Le problème a été abordé pour la première fois dans le
cadre de la synthèse, dans [PR90] avec des spécifications LTL, puis étendu aux spécifications
CTL∗ dans [KV01]. Contrairement au cas centralisé, le problème est indécidable en général
dans les systèmes distribués synchrones, et très peu de sous-classes décidables ont pu être
identifiées. Les systèmes à comportement asynchrone sont des systèmes dans lesquels chaque
processus a sa vitesse d’exécution propre. Le problème de synthèse de systèmes asynchrones
a tout d’abord été abordé dans le cas centralisé avec des spécifications de temps linéaire,
où le processus et son environnement évoluent de façon asynchrone [PR89b, Var95]. Puis,
le problème de contrôle dans le cas distribué asynchrone a été étudié dans [MT02b]. Ils obtiennent la décidabilité du problème sous des restrictions très fortes. Plus tard, les travaux de
[GLZ04, MTY05] ont également abordé ce problème, en autorisant une mémoire plus puissante aux contrôleurs, ce qui permet d’élargir un peu ces résultats. Enfin, [FS06] ont traité
le problème de synthèse de systèmes distribués pour des spécifications en logique de temps
arborescent, avec un modèle de communication par variables partagées. Encore une fois, les
résultats provenant de la théorie des jeux restent utiles pour résoudre les problèmes de synthèse et de contrôle dans le cas distribué. Les résultats de [PR90] tant de décidabilité que
d’indécidabilité se basent sur des travaux sur les jeux multi-joueurs de [PR79]. Un formalisme
de jeux multi-joueurs adapté à la synthèse et au contrôle de systèmes distribués a été proposé
[MW03, BJ05]. Ces travaux proposent un cadre abstrait dans lequel s’encodent les problèmes
de synthèse et de contrôle des systèmes distribués, tant synchrones qu’asynchrones, et donnent
des conditions sur la structure des jeux permettant d’obtenir la décidabilité.
On peut enfin relever que le problème de synthèse de systèmes ouverts a également été
étudié pour des spécifications dans des logiques épistémiques de temps linéaire, dans [vdMV98]
pour les systèmes centralisés, et étendus aux systèmes distribués dans [vdMW05].
Contributions de la thèse
Dans cette thèse est abordé le problème de synthèse de systèmes distribués ouverts, dans
les cas à la fois de comportement synchrone et asynchrone. Dans le cas de systèmes distribués, l’indécidabilité du problème de synthèse est très vite atteinte. On peut espérer obtenir
des solutions positives, en restreignant la généralité du problème, et en particulier en limitant le pouvoir d’expression des spécifications. On défend dans ce travail l’idée que des
spécifications raisonnables doivent être externes. Sont externes des spécifications ne décrivant
que les interactions entre le système vu dans son ensemble et l’environnement, à l’exclusion
des communications entre les processus du système eux-mêmes (ceci, en opposition avec des
spécifications dites totales). En effet, d’un point de vue applicatif, la description des bons
comportements d’un système distribué ne devrait concerner que les actions visibles, c’est-àdire les sorties du système en fonction des entrées faites par l’environnement, le système en
lui-même se comportant comme une boı̂te noire.
5
Le chapitre 2 commence par décrire les différents outils mathématiques utilisés dans ce
document. Parmi les modèles utilisés, qui vont permettre essentiellement de décrire les comportements de nos systèmes, on trouve les mots, finis ou infinis, qui formalisent les exécutions
des systèmes réactifs, vus comme des séquences d’actions du système ou de l’environnement,
mais également les arbres. Comme on l’a mentionné, même lorsque l’on considère les comportements du systèmes comme des mots, les programmes que l’on cherche à considérer sont
en fait des arbres, car ils doivent prendre en compte à chaque instant les différents comportements possibles de l’environnement. Par ailleurs, on peut être amené à considérer les
exécutions comme des arbres également, lorsque le formalisme de spécification utilisé est une
logique de temps arborescent. Cette modélisation des exécutions par des mots, ou des arbres
convient bien aux systèmes centralisés, ou aux systèmes distribués synchrones. En effet, lors
d’une exécution synchrone, chaque composant du système évolue aux mêmes instants, et il
suffit de considérer un alphabet constitué de n-uplets d’actions pour décrire par un mot sur
cet alphabet le comportement de ce système distribué. Lorsque les composants du système
évoluent de manière asynchrone par contre, les actions effectuées par les différents sites sont
concurrentes. Considérer des actions globales comme on le fait dans le cas de systèmes distribués synchrones induirait une synchronisation des événements inadaptée. Une option est
alors de voir les exécutions d’un système distribué comme un mot sur l’alphabet des actions
locales, dans lequel les actions intervenant de façon concurrente sont entrelacées. Cela revient
à remplacer la notion de concurrence par celle de non-déterminisme : l’ordre d’exécution
entre deux actions concurrentes est résolu par un choix non-déterministe. Un formalisme plus
satisfaisant a été développé dans les années 70 : celui des traces de Mazurkiewicz, qui se propose de conserver la notion de concurrence de façon explicite, en représentant une exécution
par une classe d’équivalence de mots. Dans cette thèse, les spécifications seront généralement
exprimées par des formules de logique temporelle. On donne donc la syntaxe et la sémantique
de ces dernières, en particulier de LTL, CTL et CTL∗ qui sont celles qui seront le plus utilisées
dans ce document. On présente enfin la notion d’automate fini, qui sera également largement
utilisée : un automate fini (de mots ou d’arbres) permet de définir un ensemble (de mots
ou d’arbres), appelé langage. En particulier, on s’intéressera à des automates pour lesquels
la question de savoir s’ils acceptent un langage non-vide est décidable. Ils nous permettront
d’une part d’exprimer des spécifications, en décrivant de façon finie l’ensemble des exécutions souhaitées du système, et d’autre part de résoudre le problème de synthèse : en testant
si un automate d’arbres est vide ou non, on pourra décider de l’existence d’un programme
satisfaisant la spécification.
Dans la seconde partie du chapitre 2, on présente un cadre formel dans lequel on exprime le
problème de synthèse et de contrôle de systèmes distribués. En effet, de nombreux travaux ont
été effectués sur le sujet, utilisant chacun des hypothèses particulières pour le problème. On
traduit un certain nombre de ces modèles dans le formalisme que l’on a défini, ceci afin d’avoir
une vision cohérente (et plus complète) de l’état de l’art présenté succinctement dans cette
introduction, et de permettre de mieux comprendre les différences et les progrès apportés par
les différentes publications sur le sujet. Ce modèle se veut suffisamment concret pour rester
proche des intuitions que l’on peut avoir sur la définition du problème. On se base sur le modèle
des automates asynchrones de Zielonka [Zie87], que l’on a un peu étendu afin d’exprimer à la
fois le problème de contrôle des systèmes distribués synchrones et asynchrones. En particulier,
on autorise nos automates à exécuter des n-uplets d’actions (ce qui n’est pas prévu dans le
modèle originel), afin de représenter les comportements des systèmes distribués synchrones.
On définit ensuite dans ce modèle les notions de spécifications, de programmes (ou stratégies),
6
Chapitre 1. Introduction
et enfin le problème de synthèse de contrôleurs (le vocabulaire utilisé emprunte souvent au
vocabulaire issu de la théorie des jeux, en raison des similitudes que l’on a déjà relevées entre
les deux domaines). Puis on montre comment décrire dans ce modèle les travaux publiés sur
le sujet dans le cas des systèmes à exécution synchrone, et celui des systèmes à exécution
asynchrone.
Le chapitre 3 présente les résultats obtenus dans le cadre de systèmes synchrones. Pour ce
problème particulier, [PR90] ont exhibé une architecture pour laquelle le problème est indécidable pour des spécifications LTL. Depuis, les travaux sur le sujet ont principalement eu pour
objet de définir des architectures particulières pour lesquelles le problème est décidable. Un
résultat plus satisfaisant serait d’obtenir un critère de décidabilité portant en particulier sur
l’architecture de communication. En effet, la façon dont les informations de l’environnement
sont distribuées parmi les processus semble cruciale. Un tel critère de décidabilité a été défini
pour des spécifications totales dans [FS05] : ils établissent que le problème est décidable pour
les architectures dans lesquelles les processus ont une connaissance « hiérarchique » de l’état
global du système, i.e., une architecture dans laquelle on peut ordonner les processus en fonction de leur connaissance de l’état global du système. Au contraire, pour toute architecture
dans laquelle il y a deux processus ayant une connaissance incomparable de l’état global, le
problème est indécidable. Dans ce chapitre, on se place par contre dans le cas particulier des
spécifications de type externe, qui ne contraignent pas les communications entre processus. En
effet, en plus d’être plus naturelles d’un point de vue pratique, comme on l’a mentionné, les
spécifications externes permettent d’exclure des spécifications trop puissantes, rendant le problème rapidement indécidable. En effet, une spécification contraignant les interactions entre
les processus du système entre eux peut facilement interdire toute communication entre deux
processus particuliers, ce qui revient à se détacher de l’architecture même du système, en les
empêchant par exemple d’avoir toute la connaissance possible de l’état global. Par contre, avec
des spécifications externes, l’obtention d’un critère de décidabilité est plus difficile, puisque,
contrairement au cas de spécifications totales, la preuve d’indécidabilité de [PR90] ne peut
plus s’appliquer dans un aussi grand nombre de cas.
On commence par définir un modèle plus agréable pour le problème de synthèse de systèmes distribués synchrones, rendant les démonstrations plus légères, et dans lequel on autorise
les processus à fonctionner avec des délais arbitraires, ce qui constitue une généralisation des
modèles précédemment étudiés, dans lesquels tous les processus fonctionnaient sans délai, ou
bien avaient tous un délai d’une unité de temps. On montre que ce modèle est équivalent
au modèle du chapitre 2 pour le problème de synthèse. Puis, on montre que, dans le cas de
spécifications externes, l’indécidabilité mise en évidence dans [PR90] se généralise aux architectures à information incomparable : une architecture est à information incomparable s’il
existe deux processus avec sortie recevant des ensembles d’informations incomparables de
l’environnement (éventuellement de façon indirecte). Dans certains cas, cette condition peut
être vue comme une condition d’accessibilité dans le graphe de communications du système :
existe-t-il deux processus avec sortie, et deux entrées distinctes de l’environnement, tels qu’il
existe un chemin de communication d’une entrée vers un processus, mais pas vers l’autre, et
de la seconde entrée vers le second processus mais pas vers le premier ? La différence avec
le critère établi pour le cas de spécifications totales est qu’on restreint cette condition sur la
connaissance de l’état global aux processus en sortie, tandis que dans le premier cas, tous
les processus sont concernés. C’est donc un nombre bien plus restreint d’architectures qui
sont concernées par cette condition d’indécidabilité. On définit ensuite une sous-classe des
7
architectures, les architectures uniformément bien connectées, pour lesquelles on montre que
cette condition devient un critère nécessaire et suffisant d’indécidabilité. Une architecture est
uniformément bien connectée si chaque processus en sortie peut connaı̂tre à chaque instant
toutes les informations en provenance de l’environnement qui lui sont potentiellement accessibles : en effet un phénomène de goulot d’étranglement dans l’architecture peut empêcher un
processus de connaı̂tre toute l’information disponible à chaque instant, car le processus devant lui transmettre les valeurs n’a pas suffisamment de bande passante et doit échantillonner
l’information à transmettre par exemple. Tester si un système est uniformément bien connecté
revient à vérifier l’existence d’un routage possible de l’information au sein de l’architecture.
On démontre dans ce chapitre la décidabilité de ce problème, ainsi que sa complexité, puis
on montre que le problème de synthèse pour les systèmes distribués est décidable pour une
architecture uniformément bien connectée si et seulement si elle n’est pas à information incomparable. Ceci permet de mettre en évidence des architectures pour lesquelles il devient
possible de décider le problème de synthèse, alors que cela ne l’était pas dans le cas de spécifications totales. Enfin, on montre que ce critère ne s’applique plus pour les architectures dans
lesquelles les processus en sortie n’ont pas accès à toute l’information possible à chaque instant. On montre qu’il suffit à un processus de perdre un seul bit d’information pour retrouver
l’indécidabilité du problème.
Une partie des résultats de ce chapitre a été publiée dans [GSZ06] (une version longue des
résultats précédents a été publiée dans [GSZ09]).
On étudie dans le chapitre 4 le problème de synthèse de systèmes distribués en sémantique
asynchrone. Dans la littérature, ce problème a été traité sous divers angles : comme dans le cas
synchrone, le type de spécifications autorisées est un paramètre du problème, mais aussi le type
de communications autorisées entre les processus, et le type de mémoire laissée au contrôleur
(ces différents aspects seront abordés plus en détail dans le chapitre 2). On introduit ici un
nouveau paradigme de communication, que l’on appelle communication par signaux. Ce type
de communication est une synchronisation d’actions entre deux processus, mais initiée par
un seul, le processus émetteur. Le processus récepteur ne peut refuser de recevoir un signal.
Ce type de communications est plus puissant que les variables partagées (mécanisme dans
lequel un processus peut lire une variable modifiée par un autre processus, mais dans le cadre
asynchrone, il n’a aucune garantie de lire la « bonne » valeur de la variable), et plus réaliste
que la synchronisation par rendez-vous, dans laquelle les deux processus doivent se mettre
d’accord pour effectuer une action commune. Comme dans le chapitre 3, on ne considère
que des spécifications externes, dont les modèles seront des ordres partiels représentant la
partie visible des exécutions du système (les communications internes entre les processus étant
considérées invisibles par la spécification). Le choix de spécifications externes étant motivé
par la volonté de ne pas restreindre les communications entre les processus, on se restreint
à des spécifications ayant de bonnes propriétés de clôture, assurant qu’elles autorisent bien
les processus à communiquer sans restriction, dans la mesure où l’exécution visible reste
correcte. Enfin, dans les sémantiques d’exécution asynchrone, il existe des exécutions que
l’on peut considérer comme dégénérées. En effet, contrairement au cas synchrone où chaque
processus peut et doit jouer à chaque instant de l’exécution, dans les exécutions asynchrones,
on suppose généralement l’existence d’un ordonnanceur activant à chaque instant certains
des processus qui le souhaitent. Si on ne pose aucune condition sur cet ordonnanceur, on
obtient parmi les exécutions du système des cas où un processus qui le souhaitait n’a jamais
pu effectuer d’action, car saturé d’événements de la part de l’environnement par exemple. Une
8
Chapitre 1. Introduction
façon d’éliminer ces cas pathologiques et de considérer que l’on a un ordonnanceur équitable.
On ne confronte alors à la spécification que les exécutions dites équitables du système. La
synthèse équitable avait été abordée dans le cas centralisé [Var95, AM94]. On introduit dans
ce chapitre une notion d’équité pour la synthèse de systèmes distribués asynchrones. Sous
ces hypothèses, on montre que le problème est décidable pour toute la classe d’architectures
fortement connexes (i.e., dans lesquelles chaque processus peut envoyer un signal à chacun des
autres, éventuellement en le faisant transmettre par des processus intermédiaires). Ce résultat
constitue un progrès par rapport au cas synchrone en particulier, dans lequel les architectures
fortement connexes sont en général indécidables.
Des résultats préliminaires à ceux décrits dans ce chapitre ont été publiés dans [CGS09].
Chapitre 2
Formalismes
Sommaire
1
2
Définitions utiles . . . . . . . . . . . . . . . . . . . . .
1.1
Modèles . . . . . . . . . . . . . . . . . . . . . . . . .
1.2
Logiques temporelles . . . . . . . . . . . . . . . . . .
1.3
Automates finis . . . . . . . . . . . . . . . . . . . . .
Le problème de synthèse et de contrôle distribués .
2.1
Cadre général . . . . . . . . . . . . . . . . . . . . . .
2.2
Comportement synchrone . . . . . . . . . . . . . . .
2.3
Comportement asynchrone . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . 9
. . . . .
9
. . . . . 12
. . . . . 15
. . . . . 17
. . . . . 17
. . . . . 24
. . . . . 38
Ce chapitre fixe les formalismes qui vont être utilisés dans ce manuscrit. La première
section reprend des définitions classiques qui seront utiles pour exposer les résultats de cette
thèse. La seconde section est une présentation personnelle du problème de synthèse de contrôleurs distribués : on y introduit un cadre uniforme dans lequel intégrer les différents travaux
effectués sur le sujet. Cette tentative peut se rapprocher du travail de [MW03], mais l’objectif
est différent : on cherche ici non pas un formalisme abstrait permettant de mettre en valeur
ou démontrer des résultats généraux, mais plutôt à définir un modèle plus concret rendant
compte des différents choix de modélisation faits dans les travaux de la littérature (même si
cela rend certains résultats plus difficiles à démontrer). On espère ainsi donner une vision uniforme des différents formalismes choisis, et on se donne les outils pour comparer les résultats
déjà obtenus à ceux que l’on développera dans les chapitres suivants.
1
Définitions utiles
1.1
1.1.1
Modèles
Mots
Un alphabet Σ est un ensemble fini de symboles. Une séquence d’éléments de Σ est appelée
un mot. Si σ = s1 s2 · · · sn est un mot fini, n est la longueur de σ noté |σ| = n. Si σ = s1 s2 · · ·
est un mot infini, |σ| = ω. Le mot de longueur 0 est appelé mot vide et est dénoté ε. On note
Σ∗ l’ensemble des mots finis de Σ, Σ+ l’ensemble des mots finis non vides et Σω l’ensemble
des mots infinis. On note Σ∞ = Σ∗ ⊎ Σω l’ensemble des mots finis ou infinis de Σ.
9
10
Chapitre 2. Formalismes
Pour tous mots σ = s1 · · · sn et σ ′ = s′1 · · · s′m , on définit la concaténation σ · σ ′ = s1 · · · sn ·
L’ensemble (Σ, ·, ε) forme un monoı̈de, ou monoı̈de libre généré par Σ.
Soient Σ et Σ′ deux alphabets tels que Σ′ ⊆ Σ. Soit σ ∈ Σ∗ un mot fini de Σ. On définit
la projection de σ sur Σ′ , noté πΣ′ (σ) par
s′1 · · · s′m .


ε
πΣ′ (σ) = πΣ′ (u)


πΣ′ (u)a
si σ = ε
si σ = ua et a ∈
/ Σ′
si σ = ua et a ∈ Σ′
Soit σ ∈ Σ∞ . On définit l’ensemble des préfixes de σ comme étant Pref(σ) = {u | ∃v, uv =
σ}. La relation préfixe est une relation binaire ⊑ sur Σ∞ telle que σ ′ ⊑ σ si et seulement si
σ ′ ∈ Pref(σ). La relation ⊑ est une relation d’ordre.
Pour un mot σ ∈ Σω , on définit sa projection sur Σ′ par
πΣ′ (σ) =
G
πΣ′ (σ ′ ).
σ ′ ∈ Σ∗ ,
σ′ ⊑ σ
Le préfixe de longueur i ≤ |σ| d’un mot σ est noté σ[i]. Par convention, on considère que
si i ≤ 0, σ[i] = ε. Pour un mot σ = s1 s2 · · · ∈ Σ∞ , pour tout i, j entiers, on note σ[i . . . j] le
facteur formé des lettres si · · · sj , qui est vide si i > j. On utilise aussi cette notation si i ≤ 0
ou j ≤ 0 : si j ≤ 0, alors σ[i · · · j] = ε, et si i ≤ 0 < j alors σ[i · · · j] = σ[1 · · · j].
Soit σ ∈ Σω . On définit l’ensemble des lettres apparaissant infiniment souvent dans σ,
noté inf (σ) = {a ∈ Σ | |π{a} (σ)| = ω}.
Un sous-ensemble L de Σ∞ est appelé un langage. Si L et K sont deux langages de
mots finis, la concaténation de L et K, notée L · K, est l’ensemble des mots uv formés par
concaténation de u ∈ L et v ∈ K. Pour n entier positif, on note Ln la puissance n-ième de L,
définie par
L0 = {ε}
Ln = Ln−1 · L si n>0.
Pour N > 0, on note L<N =
de L plus petites que N .
1.1.2
S
n<N
Ln le langage formé par union de toutes les puissances
Arbres
Étant donnés un ensemble fini X et un ensemble Y , un X-arbre Y -étiqueté (appelé aussi
(X, Y )-arbre) est une fonction t : X ∗ → Y dont le domaine de définition est clos par préfixe,
dans laquelle les éléments de X sont appelées directions et les éléments de Y sont appelés
étiquettes. Lorsque la fonction est totale, on dit que l’arbre est complet. Un mot σ ∈ X ∗
définit un nœud de t et t(σ) est son étiquette. Le mot vide ε est la racine de l’arbre. Un mot
σ ∈ X ∞ est une branche. Une branche σ est maximale si σ ∈ dom(t) et, pour tout s ∈ X,
σ·s∈
/ dom(t).
On dit que t′ est un sous-arbre de t si dom(t′ ) ⊆ dom(t).
11
1. Définitions utiles
1.1.3
Ordres partiels
Soit t = (V, ≤) un ensemble partiellement ordonné, et H ⊆ V . On note ↓t H = {x ∈
V | ∃h ∈ H, x ≤ h} le passé de H dans t. Lorsqu’il n’y a pas d’ambiguı̈té sur t on écrira
simplement ↓H. On notera également ↓x = ↓{x} et ⇓x = ↓x \ {x}.
On notera la relation successeur par ⋖ = < \ <2 .
De plus, lorsque x et y sont deux événements de t non ordonnés, i.e., tels que x 6≤ y et
y 6≤ x, on notera x kt y.
Définition 2.1 (Ordre partiel étiqueté). Un ordre partiel étiqueté par Σ est un triplet t =
(V, ≤, λ) où (V, ≤) est un ordre partiel, et λ : V → Σ une fonction d’étiquetage des événements
par des actions. Deux ordres partiels étiquetés t1 = (V1 , ≤1 , λ1 ) et t2 = (V2 , ≤2 , λ2 ) sont
isomorphes s’il existe une bijection ϕ : V1 → V2
– préservant l’ordre : (x ≤1 y) ⇔ (ϕ(x) ≤2 ϕ(y))
– et préservant l’étiquetage : λ1 (x) = λ2 (ϕ(x))
On dit qu’un ordre partiel étiqueté par Σ, t′ = (V ′ , ≤′ , λ′ ), est une extension de t s’il existe
une bijection ϕ : V → V ′ telle que, pour tout x, y ∈ V , x ≤ y implique que ϕ(x) ≤′ ϕ(y)
et λ(x) = λ′ (ϕ(x)). Si ≤′ est un ordre total, on dit que t′ est une extension linéaire (ou
linéarisation) de t.
Pour t = (V, ≤, λ), ordre partiel étiqueté par Σ, et pour tout Σ′ ⊆ Σ, on note πΣ′ (t) =
(V ′ , ≤′ , λ′ ) la projection de t sur Σ′ définie par
V ′ = λ−1 (Σ′ )
≤′ =≤ ∩(V ′ × V ′ )
λ′ = λ|Σ′
1.1.4
Traces de Mazurkiewicz
La théorie des traces de Mazurkiewicz [Maz77, Maz86] (voir aussi [RD95]) a été développée
dans le but de fournir un cadre formel adapté précisément à la représentation et l’analyse des
exécutions de systèmes distribués. En effet, dans un système distribué, où deux actions peuvent
avoir lieu de façon indépendante sur deux sites distincts, considérer les exécutions comme des
mots implique de choisir un ordre entre ces deux actions, ce qui revient à supposer que deux
actions concurrentes vont être exécutées dans un ordre choisi de façon non-déterministe. Au
contraire, les traces de Mazurkiewicz ne retiennent un ordre entre deux actions que si celles-ci
sont liées par une relation de causalité, notion qui est traduite dans le modèle par la notion
de dépendance.
Définition 2.2 (Alphabet de dépendance). Un alphabet de dépendance est une paire (Σ, D)
où Σ est un ensemble fini d’actions et D ⊆ Σ × Σ est une relation réflexive et symétrique
appelée relation de dépendance. Son complémentaire I= Σ × Σ \ D est appelé relation d’indépendance.
Définition 2.3 (Trace de Mazurkiewicz). Une trace de Mazurkiewicz sur (Σ, D) est, à isomorphisme près, un ordre partiel étiqueté par Σ, t = (V, ≤, λ), vérifiant :
1. pour tout x ∈ V , l’ensemble ↓x est fini,
2. pour tout x, y ∈ V , x ⋖ y ⇒ λ(x) D λ(y),
12
Chapitre 2. Formalismes
3. pour tout x, y ∈ V , λ(x) D λ(y) ⇒ x ≤ y ou y ≤ x.
Lorsque l’ensemble V est fini, on dit que la trace t est finie, et lorsqu’il est infini, qu’elle
est infinie. On note R(Σ, D) l’ensemble des traces finies et infinies sur (Σ, D) et M(Σ, D)
l’ensemble des traces finies sur (Σ, D) (on pourra se référer utilement à [GP95] pour une
présentation des traces infinies).
Définition 2.4 (Trace préfixe). Une trace t′ = (V ′ , ≤′ , λ′ ) est préfixe de la trace t = (V, ≤, λ)
si
– V′ ⊆V
– pour tout x, y ∈ V ′ , x ≤′ y ⇔ x ≤ y
– pour tout x ∈ V ′ , λ′ (x) = λ(x)
– V ′ est clos par le bas : ↓t V ′ = V ′ .
Il existe une application surjective des mots dans les traces [ ] : Σ∞ → R(Σ, D) définie
comme suit. Soit u un mot de Σ∞ et soit V = {i ∈ N | 0 ≤ i < |u|}. Considérons alors l’ordre
total tu = (V, ≤). Le mot u définit naturellement un fonction d’étiquetage λu : V → Σ :
si u = a0 a1 · · · ∈ Σ∞ , on pose λu (i) = ai et on peut identifier u à l’ordre partiel étiqueté
(V, ≤, λu ). Alors [u] = (V, ⊑, λu ) avec ⊑ = R∗ et R ⊆ V × V défini par x R y si et seulement
si x ≤ y et (λ(x) D λ(y)).
En fait, tout mot u de Σ∞ est la linéarisation d’une unique trace de R(Σ, D), et toute
trace de R(Σ, D) admet au moins une linéarisation dans Σ∞ .
On remarque par ailleurs que [Σ∗ ] = M(Σ, D).
Définition 2.5 (Concaténation de traces). Soient t1 = (V1 , ≤1 , λ1 ) ∈ M(Σ, D) et t2 = (V2 , ≤2
, λ2 ) ∈ M(Σ, D) deux traces finies. On note t1 · t2 = (V, ≤, λ) ∈ M(Σ, D) l’unique trace de
Mazurkiewicz telle que
– V = V1 ⊎ V2 ,
– λ|V1 = λ1 ,
– λ|V2 = λ2 ,
– ≤ ∩(V1 × V1 ) = ≤1 ,
– ≤ ∩(V2 × V2 ) = ≤2 ,
– pour tout x1 ∈ V1 , pour tout x2 ∈ V2 , x1 ≤ x2 si et seulement si λ(x1 ) D λ(x2 ),
– pour tout x1 ∈ V1 , pour tout x2 ∈ V2 , x2 6≤ x1 .
Pour t ∈ M(Σ, D) et a ∈ Σ, on note t · a ∈ M(Σ, D) la trace t · ta avec ta = ({x}, =, λ) où
λ(x) = a.
1.2
Logiques temporelles
Les logiques temporelles sont des logiques modales permettant de spécifier des relations
temporelles entre des événements (au cours d’une exécution d’un système typiquement). Leur
utilisation pour raisonner sur le comportement des programmes est due à [Pnu77]. On distingue les logiques temporelles linéraires des logiques temporelles arborescentes.
1.2.1
Logique temporelle linéaire : LTL
La logique temporelle LTL (Linear Temporal Logic) a été introduite [Pnu77, Kam68,
GPSS80] pour raisonner sur une exécution particulière du système. Sa syntaxe est la sui-
13
1. Définitions utiles
vante :
ϕ ::=⊥ | ⊤ | p | ¬ϕ | ϕ ∨ ϕ |
Xϕ | ϕ U ϕ
où p est une proposition atomique d’un ensemble dénombrable AP .
Les opérateurs temporels, X (next) et U (until), permettent respectivement d’exprimer
qu’une formule est vraie à l’instant suivant de l’exécution, et qu’une certaine formule est
vérifiée à tout instant jusqu’à ce qu’une autre formule soit vraie.
Formellement, les modèles de LTL sont des exécutions vues comme des mots finis ou
infinis de 2AP . Un modèle de LTL est donc une séquence de taille |u| assimilée à l’application
u : {i ∈ N | 0 ≤ i < |u|} → 2AP . De façon équivalente, un modèle peut également être vu
comme un mot u ∈ (2AP )ω , avec u = u0 u1 · · · , l’application associant alors à u(i) la lettre ui ,
ou comme un ordre total étiqueté par 2AP . Étant donnés AP un ensemble de propositions
atomiques, u un modèle, 0 ≤ i < |u| une position et ϕ une formule de LTL, on définit par
récurrence la relation de satisfaction |= de la façon suivante :
– u, i |= ⊤
– u, i 6|= ⊥
– u, i |= p si et seulement si p ∈ u(i)
– u, i |= ¬ϕ si et seulement si u, i 6|= ϕ
– u, i |= ϕ ∨ ψ si et seulement si u, i |= ϕ ou u, i |= ψ
– u, i |= X ϕ si et seulement si i + 1 < |u| et u, i + 1 |= ϕ
– u, i |= ϕ U ψ si et seulement si il existe j < |u| tel que i ≤ j et u, j |= ψ et, pour tout
i ≤ k < j, u, k |= ϕ.
def
On peut définir les connecteurs supplémentaires classiques ϕ ∧ ψ = ¬(¬ϕ ∨ ¬ψ) et ϕ →
def
def
ψ = ¬ϕ ∨ ψ, ainsi que les modalités temporelles F ϕ = (⊤ U ϕ) signifiant que la propriété ϕ
def
est vérifiée à un moment ultérieur de l’exécution, G ϕ = ¬(F ¬ϕ) signifiant que la propriété ϕ
def
est vraie à tous les moments ultérieurs de l’exécution, et ϕ R ψ = ¬(¬ϕ U ¬ψ) signifiant que
l’obligation de vérifier ψ cesse lorsque ϕ est vérifiée : ψ est vraie jusqu’à ce que ϕ soit vraie
def
(si ϕ est vérifiée un jour). Un autre opérateur utile est le weak until ϕ W ψ = G ψ ∨ (ϕ U ψ),
signifiant que la propriété ϕ est vérifiée tant que la propriété ψ n’est pas vérifiée, tout en
autorisant la possibilité que ψ ne soit jamais vérifiée.
On dit qu’une séquence u satisfait la formule ϕ si u, 0 |= ϕ et on notera généralement
u |= ϕ.
On peut également introduire des opérateurs faisant référence au passé [Pri67]. L’opérateur
Y ϕ se lit « la formule ϕ est vraie à l’instant précédent » et l’opérateur ϕ S ψ se lit « ψ a été
vraie et depuis, ϕ est vraie ». Formellement leur sémantique est donnée par
– u, i |= Y ϕ si et seulement si i > 0 et u, i − 1 |= ϕ,
– u, i |= ϕ S ψ si et seulement si il existe 0 ≤ j ≤ i tel que u, j |= ψ et pour tout j < k ≤ i,
u, k |= ϕ.
def
Comme dans le cas « pur futur », on peut définir la modalité H ϕ = (⊤ S ϕ). Il a été montré dans [GPSS80, Gab87] que les modalités passées n’ajoutent pas d’expressivité lorsqu’on
interprète les formules sur les modèles depuis l’origine. Par la suite, sauf mention contraire,
on ne considérera la logique LTL que dans sa version ne contenant pas les modalités passées.
14
1.2.2
Chapitre 2. Formalismes
Logiques temporelles arborescentes : CTL et CTL∗
Les logiques temporelles arborescentes supposent une vision branchante du temps. À un
instant donné, plusieurs futurs sont possibles, tandis que dans les logiques temporelles linéaires, on considère l’exécution fixée dès le départ. Ceci implique que des propriétés comme
« Depuis tout état où p est vérifiée, il est possible d’atteindre un état où q est vérifiée » ne
peuvent être exprimées en LTL. Les logiques arborescentes ont donc été introduites pour pallier ce manque. Une logique temporelle arborescente est une logique capable de quantifier sur
les chemins. Des exemples standards de telles logiques sont CTL (Computation Tree Logic)
[CE81], CTL∗ [EH83] et le µ-calcul modal [Koz83].
La syntaxe de CTL∗ est définie par la grammaire suivante :
Φ ::= ⊤ | ⊥ | p | ¬Φ | Φ ∨ Φ | E ψ
ψ ::= Φ | X ψ | ψ U ψ
où p est une proposition atomique d’un ensemble dénombrable AP . Les formules Φ sont des
formules d’état, et les formules ψ sont des formules de chemin. L’opérateur E (à rapprocher
de l’opérateur existentiel ∃ de la logique du premier ordre) permet d’exprimer qu’à partir de
l’état courant, il existe une exécution vérifiant une formule.
Les modèles de CTL∗ sont des arbres pour lesquels on associe à chaque nœud un ensemble
de propositions atomiques de AP .
On note pour n ∈ N, Nn = {0, . . . , n} et Nω = N. Formellement, étant donnés t : X ∗ →
AP
2
un arbre, σ ∈ X ∞ une branche maximale de t, i ∈ N|σ| une position, et Φ une formule
de CTL∗ on définit par récurrence la relation de satisfaction |= de la façon suivante :
– t, σ, i |= ⊤
– t, σ, i 6|= ⊥
– t, σ, i |= p si et seulement si p ∈ t(σ[i]))
– t, σ, i |= ¬Φ si et seulement si t, σ, i 6|= Φ
– t, σ, i |= Φ1 ∨ Φ2 si et seulement si t, σ, i |= Φ1 ou t, σ, i |= Φ2
– t, σ, i |= E ψ si et seulement si il existe σ ′ ∈ X ∞ telle que σ[i] · σ ′ est une branche
maximale de t et t, σ[i] · σ ′ , i |= ψ
– t, σ, i |= X ψ si et seulement si i + 1 ∈ N|σ| et t, σ, i + 1 |= X ψ
– t, σ, i |= ψ1 U ψ2 si et seulement si il existe j ∈ N|σ| tel que i ≤ j et t, σ, j |= ψ2 et pour
tout i ≤ k < j, t, σ, k |= ψ1
On peut comme précédemment définir les connecteurs logiques ∧ et → ainsi que les modalités temporelles F, G et R. On peut également définir l’opérateur de chemin dual de E par
def
A ψ = ¬ E ¬ψ, signifiant intuitivement que la propriété ψ est vérifiée sur tous les chemins
partant du nœud courant.
On dit qu’un arbre t satisfait une formule d’état Φ de CTL∗ (noté t |= Φ) si t, σ, 0 |= Φ
avec σ branche maximale quelconque de t.
Il est clair que LTL est un fragment de CTL∗ . Un autre fragment bien connu de CTL∗ est
la logique CTL définie par
Φ ::= ⊤ | ⊥ | p |¬Φ | Φ ∨ Φ | EX Φ | E Φ U Φ | EG Φ
Les formules de CTL ne s’interprètent donc que sur les états, et non sur les chemins.
En fait, il se trouve que les logiques LTL et CTL ont des pouvoirs d’expression incomparables, et la logique CTL∗ et est plus expressive que LTL et CTL. Le µ-calcul que nous ne
définirons pas ici est plus expressif que CTL∗ .
1. Définitions utiles
1.3
1.3.1
15
Automates finis
Automates de mots
Définition 2.6. Un automate de mots est un quintuplet A = (Σ, Q, δ, q0 , Ω) où
– Σ est un alphabet fini,
– Q est un ensemble fini d’états (que l’on suppose non vide),
– q0 est l’état initial,
– δ : Q × Σ → 2Q est la fonction de transition, et attribue à un état et une lettre un
ensemble d’états successeurs,
– Ω ⊆ Q est la condition d’acceptation.
La condition d’acceptation Ω peut prendre différentes formes :
– si A est un automate sur les mots finis, Ω ⊆ Q,
– si A est un automate de Büchi sur les mots infinis, Ω ⊆ Q,
– si A est un automate de Rabin sur les mots infinis, Ω ⊆ 2Q × 2Q .
L’automate A est déterministe si pour tout q ∈ Q, et a ∈ Σ, |δ(q, a)| ≤ 1.
Une exécution de A sur un mot σ = s1 s2 · · · ∈ Σ∞ est une séquence ρ = r0 s1 r1 · · · ∈
Q · (Σ · Q)|σ| telle que r0 = q0 , et pour tout 0 ≤ i < |σ|, ri+1 ∈ δ(ri , si+1 ). Une exécution
acceptante est définie en fonction du type de l’automate considéré :
– Une exécution ρ d’un automate sur les mots finis est acceptante sur le mot σ ∈ Σ∗ si le
dernier état visité est acceptant, i.e., si r|σ| ∈ Ω.
– Une exécution ρ d’un automate de Büchi est acceptante sur σ ∈ Σω si l’automate visite
infiniment souvent au cours de l’exécution un état acceptant, i.e. si inf (πQ (ρ)) ∩ Ω 6= ∅,
– Une exécution ρ d’un automate de Rabin est acceptante sur le mot σ ∈ Σω s’il existe
une paire (L, U ) ∈ Ω telle que inf (πQ (ρ)) ∩ U 6= ∅ et inf (πQ (ρ)) ∩ L = ∅.
On dit qu’un mot σ ∈ Σ∞ est accepté par A s’il existe une exécution acceptante de A sur
ce mot. L’ensemble des mots acceptés par un automate A est appelé le langage de l’automate
A et noté L(A).
Un langage L ⊆ Σ∗ est dit régulier s’il existe un automate A tel que L(A) = L.
Un langage L ⊆ Σω est dit ω-régulier s’il existe un automate de Büchi A tel que L(A) = L.
1.3.2
Automates d’arbres
Automates d’arbres non-déterministes On définit ici les automate sur des arbres complets.
Définition 2.7 (Automate d’arbres non-déterministe). Un automate d’arbres non-déterministe est un sextuplet A = (X, Y, Q, Q0 , δ, α) avec
– X l’ensemble des directions,
– Y l’ensemble (fini) des étiquettes,
– Q l’ensemble des états,
– Q0 ⊆ Q les états initiaux,
X
– δ : Q × Y → 2Q la fonction de transition qui associe à un état et une étiquette un
ensemble de fonctions attribuant à chaque direction de l’arbre un état successeur,
– α ⊆ Qω la condition d’acceptation.
16
Chapitre 2. Formalismes
On assimile le n-uplet (qx )x∈X à l’application X → Q définie par x 7→ qx . Une exécution
d’un automate non-déterministe A sur un (X, Y )-arbre t est un arbre ρ : X ∗ → Q telle que
ρ(ε) ∈ Q0 et pour tout σ ∈ X ∗ , (ρ(σ · x))x∈X ∈ δ(ρ(σ), t(σ)). Une exécution est acceptante
si toutes ses branches x1 x2 · · · ∈ X ω sont telles que ρ(ε)ρ(x1 )ρ(x1 x2 ) · · · ∈ α. Comme pour
les mots, il existe différents types de conditions d’acceptation (Büchi, Rabin, parité,. . .). Par
contre, contrairement au cas des mots, [Rab70] a montré que les automates d’arbres de Büchi
étaient strictement moins expressifs que les automates d’arbres de Rabin. Pour plus de précisions, on pourra se référer par exemple à [Tho90]. Un (X, Y )-arbre t est accepté par A s’il
existe une exécution acceptante de A sur t.
Comme pour les mots, l’ensemble des (X, Y )-arbres acceptés par A est noté L(A).
Automates d’arbres alternants Un automate d’arbres alternant (notion introduite par
[MS87]) se définit comme un automate non-déterministe, à la différence que lors d’une transition, on peut choisir d’envoyer plusieurs copies de l’automate dans la même direction de
l’arbre ou d’ignorer une direction en ne la visitant pas du tout. Ces automates généralisent
donc les automates non-déterministes en définissant une transition à l’aide d’une formule logique. Formellement, soit B + (X) l’ensemble des formules booléennes positives sur les éléments
de X défini par
Φ ::= ⊤ | ⊥ | p | α ∨ α | α ∧ α
avec p ∈ X. Un ensemble Y ⊆ X satisfait une formule Φ ∈ B + (X) (on notera Y |= Φ) si la
valuation qui affecte ⊤ à tout élément de Y et ⊥ à tout élément de X \ Y vérifie Φ.
Définition 2.8 (Automate d’arbres alternant). Un automate d’arbres alternant est un sextuplet A = (X, Y, Q, q0 , δ, α) avec
– X l’ensemble des directions,
– Y l’ensemble (fini) des étiquettes,
– Q l’ensemble des états,
– q0 l’état initial,
– δ : Q × Y → B + (X × Q) la fonction de transition,
– α ⊆ Qω la condition d’acceptation.
La fonction de transition associe donc à un état et une étiquette une formule qui suggère
une nouvelle configuration de l’automate. Par exemple, si X = {0, 1}, la transition définie
par δ(q, x) = (0, q1 ) ∧ (0, q2 ) ∨ (0, q2 ) ∧ (1, q2 ) ∧ (1, q3 ) signifie que lorsque l’automate est dans
l’état q et lit la lettre x, il peut soit envoyer deux copies, une dans l’état q1 , l’autre dans l’état
q2 dans la direction 0, soit envoyer une copie dans la direction 0, dans l’état q2 et envoyer
deux copies, une dans l’état q2 , l’autre dans l’état q3 dans la direction 1. Il est clair qu’un
automate non-déterministe est un cas particulier d’automate alternant, dans lequel la fonction
de transition pour chaque état et chaque direction,
V réécrite sous forme normale disjonctive
propose une disjonction de formules de la forme x∈X {x} × Q.
Une exécution d’un automate alternant A sur un (X, Y )-arbre t est un arbre ρ : Xr∗ →
X ∗ × Q, où Xr est un ensemble de directions vérifiant, pour tout σr ∈ dom(ρ), s’il existe
q ∈ Q et σ ∈ X ∗ tel que ρ(σr ) = (σ, q) alors, pour tout xr ∈ Xr tel que σr · xr ∈ dom(ρ),
il existe x ∈ X et qx ∈ Q tel que ρ(σr · xr ) = (σ · x, qx ). On définit de plus l’ensemble
Sσr = {(x, qx ) ∈ X × Q | il existe xr ∈ Xr tel que ρ(σr · xr ) = (σ · x, qx )}. On demande alors
que ρ vérifie :
– ρ(ε) = (ε, q0 ),
2. Le problème de synthèse et de contrôle distribués
17
– pour tout σr ∈ Xr∗ tel qu’il existe q ∈ Q, σ ∈ X ∗ tels que ρ(σr ) = (σ, q), alors Sσr |=
δ(q, t(σ)).
Une exécution est acceptante si toutes ses branches x1 x2 · · · ∈ (Xr )ω sont telles que
πQ (ρ(ε))πQ (ρ(x1 ))πQ (ρ(x1 x2 )) · · · ∈ α. Un (X, Y )-arbre t est accepté par A s’il existe une
exécution acceptante de A sur t.
Une fois de plus, on note L(A) l’ensemble des arbres accepté par l’automate alternant A.
En fait, les automates d’arbres alternants ne sont pas plus expressifs que les automates
d’arbres non-déterministes, mais ils sont exponentiellement plus succints :
Théorème 2.9 ([MS95]). Un automate d’arbres alternant de Rabin avec m états et k paires
peut être transformé en un automate d’arbres non déterministe de Rabin, reconnaissant le
même langage, ayant mO(mk) états, et O(mk) paires.
2
Le problème de synthèse et de contrôle distribués
On va présenter dans cette section un formalisme dans lequel exprimer le problème de
contrôle de systèmes distribués, et donner un certain nombre de résultats reliés à nos travaux.
2.1
Cadre général
Le problème général peut s’exprimer de la façon suivante : étant donnés un système
constitué de plusieurs composants, et une spécification précisant les comportements désirables
de ce système, on cherche à produire automatiquement des programmes pour les différents
composants assurant que l’ensemble des comportements du système satisfait la spécification.
Dans le cas du contrôle, le comportement des processus est déjà en partie déterminé par des
programmes, et il s’agit donc de restreindre ces comportements de façon à ne pas violer la
spécification. En fait, le problème de synthèse est un cas particulier du problème de contrôle :
celui où le programme disponible pour chaque processus autorise à chaque instant toutes les
actions possibles.
Dans cette thèse on s’est intéressé au problème de synthèse de programmes réactifs et
ouverts, i.e., interagissant avec un environnement non contrôlable. Dans ce cadre, on veut que
le système satisfasse la spécification quel que soit le comportement de l’environnement. On
présente maintenant plus précisément un certain nombre de travaux effectués ces dernières
années sur le sujet, en utilisant le formalisme suivant.
Les systèmes sont représentés par des automates asynchrones tels que définis par Zielonka
dans [Zie87] (voir aussi [Zie95]). On considère donc qu’un système est constitué d’un ensemble
de registres (ou variables), et d’actions agissant sur ces registres : les actions peuvent lire et
modifier certains registres. Cependant, pour capturer dans un même formalisme les exécutions
de type asynchrone et de type synchrone, nous allons définir une sémantique plus générale
que la sémantique originale ; alors que dans [Zie87], on exécute une action à la fois, on va
autoriser plusieurs actions à être jouées simultanément (et non pas de façon concurrente).
18
Chapitre 2. Formalismes
a1
r1
b
r2
a2
r3
c
r4
Fig. 2.1 – Une signature
2.1.1
Système distribué.
Une signature est un triplet (Σ, V, E) dans lequel
Σ est un alphabet d’actions
V est un ensemble de variables, ou registres
E ⊆ (V × Σ) ∪ (Σ × V )
La relation E indique, pour chaque action a ∈ Σ, quelles sont les variables que a peut lire
(E −1 (a)) et lesquelles a peut modifier (E(a)).
Exemple 2.10. Soient
Σ = {a1 , a2 , b, c},
V = {r1 , r2 , r3 , r4 },
E = {(a1 , r1 ), (a1 , r2 ), (a2 , r2 ), (a2 , r3 ), (b, r1 ), (c, r4 )}
∪ {(r1 , b), (r1 , c), (r2 , c), (r3 , c), (r4 , a1 ), (r4 , a2 )}
les éléments d’une signature. Celle-ci est représentée sur la figure 2.1, dans laquelle les actions
sont représentées par des rectangles, et les variables par des cercles. Par exemple, l’action c
modifie le registre r4 en fonction des valeurs de r1 , r2 et r3 , et l’action b lit et modifie le seul
registre r1 .
La signature définit donc en quelque sorte le squelette du système. Pour pouvoir décrire
son comportement, on dote chaque variable v d’un domaine S v qu’on supposera fini, et on
donne une sémantique à chaque action a ∈ Σ : chaque action a est associée à une fonction
−1
partielle δa : S E (a) → S E(a) , appelée transition locale de l’action a qui définit la façon
dont a modifie ses variables en écriture en fonction de la valeur de ses variables en lecture.
On remarque, que, contrairement au modèle originel, les transitions δa sont des fonctions
déterministes. En effet, les contrôleurs que l’on cherche à synthétiser vont autoriser ou non
des actions du système, et on considérera toujours que l’effet de cette action sur les registres
concernés est déterminé, i.e., en choisissant une action, un contrôleur connaı̂t l’effet de cette
action sur les registres.
19
2. Le problème de synthèse et de contrôle distribués
Un système distribué, (ou architecture) est un tuple A = (Σ, V, E, (S v )v∈V , s0 , ∆) dans
lequel
(Σ, V, E)
S
est une signature
v
pour tout v ∈ V est le domaine de la variable v
v
s0 ∈ (S )v∈V
∆ = {δa : S
E −1 (a)
indique la valeur initiale des variables
→ S E(a) | a ∈ Σ}
définit un ensemble de transitions locales
Dans le cas de systèmes ouverts, les actions de Σ sont partitionnées entre les actions
contrôlables par le système (ΣC ) et les actions non contrôlables (et donc contrôlées par l’environnement) (ΣN C ) : Σ = ΣC ⊎ ΣN C .
Un état global d’une architecture A est un tuple (sv )v∈V ∈ Πv∈v S v . Pour U ⊆ V , on notera
S U l’ensemble Πv∈U S v , et pour tout s = (sv )v∈V ∈ S V , pour tout U ⊆ V , on notera sU =
(sv )v∈U la projection de l’état s sur le sous-ensemble U des variables. On étend cette notation
U
aux séquences d’états : pour σ = s0 s1 · · · ∈ (S V )∞ , pour U ⊆ V , on note σ U = sU
0 s1 · · · .
Dans un état donné, le système peut jouer un certain nombre d’actions. Formellement, on dit
−1
qu’une action a est activable en un état s ∈ S V s’il existe s′ ∈ S E(a) tel que s′ = δa (sE (a) ).
On note en(s) l’ensemble des actions activables en s.
Exemple 2.11. Reprenons la signature de l’exemple 2.10. Pour obtenir un système distribué,
on ajoute les information suivantes. Les actions incontrôlables sont ΣN C = {a1 , a2 }, et on
suppose S v = {0, 1} pour tout v ∈ V . On définit par exemple la transition de l’action a1
par la fonction mettant tous les registres en écriture de a1 à 1 si r4 = 0 et à 0 si r4 = 1 :
δa1 (0)r1 = δa1 (0)r2 = 1 et δa1 (1)r1 = δa1 (1)r2 = 0. On définit δa2 (0)r2 = 0 et δa2 (0)r3 = 1.
Si l’action a1 est activable dans tous les états du système, ce n’est pas le cas de l’action a2 .
L’action b remplace la valeur du registre r1 par sa négation : δb (0) = 1 et δb (1) = 0, et l’action
c place dans le registre r4 la valeur de l’addition modulo 2 de tous ses registres en entrée :
δc : r1 r2 r3 r4
1 1 1
1
0 0 1
1
1
0 1 0
1 0 0
1
0
0 1 1
0
1 0 1
1 1 0
0
0
0 0 0
2.1.2
Exécutions.
Pour décrire les exécutions du système, on se dote d’un nouvel ensemble d’actions Σ′ ⊆ 2Σ
indiquant la façon dont les actions peuvent être groupées pour être exécutées en une transition
du système. On associe à Σ′ la relation E ′ ⊆ (V × Σ′ ) ∪ (Σ′ × V ) définie, pour tout A ∈ Σ′ ,
20
Chapitre 2. Formalismes
par :
E ′−1 (A) =
[
E −1 (a) = E −1 (A)
a∈A
′
E (A) =
[
E(a) = E(A)
a∈A
Pour expliciter l’effet d’une action A ∈ Σ′ sur les variables qu’elle modifie, on définira la
−1
relation δA ⊆ S E (A) × S E(A) . Dans le cas où A = {a} et a ∈ Σ, on supposera que δA = δa .
On peut à présent associer à l’architecture A un système de transition T SA = (S V , Σ′ , ⇒
, s0 ) dans lequel la relation de transition ⇒ ⊆ S V × Σ′ × S V est définie par (s, A, s′ ) ∈ ⇒ si et
−1
seulement si (sE (A) , s′E(A) ) ∈ δA , et s′v = sv pour tout v ∈ V \ E(A). En général, le système
de transition T SA est donc non-déterministe. On dit que le système de transition T SA a une
exécution sur un mot α = A1 A2 · · · ∈ Σ′∞ s’il existe une séquence d’états σ = s0 s1 · · · ∈
(S V )∞ telle que s0 est l’état initial de A et, pour tout 0 ≤ i < |α|, (si , Ai+1 , si+1 ) ∈ ⇒. On
appelle L(A) ⊆ (Σ′ )∞ l’ensemble des mots sur lesquels T SA a une exécutions et Runs(A) ⊆
S V · (Σ′ · S V )∞ l’ensemble des exécutions de T SA . Si δA est non-déterministe, on dira que A
est non-déterministe, sinon on dira qu’il est déterministe.
Les actions de Σ sont locales dans le sens où elles ne dépendent pas des valeurs de toutes
les variables, et ne modifient pas toutes les variables. En particulier, si deux actions a et b ∈ Σ
ont des domaines de lecture et d’écriture disjoints, en partant d’un état global s ∈ S V donné,
on arrive dans le même état s′ ∈ S V après avoir joué la séquence ab ou la séquence ba. Plus
précisément, on dit que deux actions a et b ∈ Σ sont causalement liées si une variable modifiée
par b est dans le domaine de lecture de a, ou si une variable modifiée par a est dans le domaine
de lecture de b, i.e., si E −1 (a) ∩ E(b) 6= ∅ ou si E(a) ∩ E −1 (b) 6= ∅. On dit que a et b sont en
conflit d’écriture si elles modifient une même variable : E(a) ∩ E(b) 6= ∅. Dans ces deux cas, le
fait d’exécuter l’action a a une influence sur le fait d’exécuter l’action b et réciproquement. On
étend cette notion aux actions de Σ′ et on définit formellement une relation de dépendance
D ⊆ Σ′ × Σ′ par
ADA′ si et seulement si (E −1 (A) ∩ E(A′ )) ∪ (E(A) ∩ E −1 (A′ )) ∪ (E(A) ∩ E(A′ )) 6= ∅ (2.1)
Remarque 2.12. L’ensemble L(A) est clos par équivalence de traces de R(Σ′ , D) : si α ∈ L(A),
alors quel que soit β ∈ Σ′∞ tel que [α] = [β], β ∈ L(A).
En effet, soit α, β ∈ Σ′∞ . Si [α] = [β] alors pour tout α′ préfixe fini de α il existe α′′ ∈ Σ′ ∗
tel que α′ α′′ est un préfixe de α et il existe β ′ préfixe fini de β tel que [α′ α′′ ] = [β ′ ] (voir par
exemple [Gas90] pour une démonstration de cette caractérisation). Supposons que α ∈ L(A).
Soit α′ ∈ Σ′ ∗ préfixe fini de α. Comme α′ α′′ et β ′ ∈ Σ′ ∗ , on sait qu’il existe une séquence
α0 , . . . , αk de mots de Σ′∗ vérifiant α0 = α′ α′′ , αk = β ′ et, pour tout 0 ≤ i < k, il existe
A, B ∈ Σ′ tels que A I B, α1 ∈ Σ′∗ , α2 ∈ Σ′∗ tels que αi = α1 ABα2 et αi+1 = α1 BAα2
(caractérisation de l’équivalence de traces sur les mots finis). De plus α′ α′′ ∈ L(A). On montre
par récurrence que pour tout i, αi ∈ L(A). Le cas de base α0 = α′ α′′ ∈ L(A) est trivialement
vérifié. Supposons maintenant que pour 0 ≤ i < k, αi ∈ L(A). Alors il existe une exécution
σ = s0 A1 s1 A2 · · · Am sm ∈ Runs(A) telle que πΣ′ (σ) = αi . Donc il existe n < m tel que
s0 A1 s1 · · · An sn est une exécution de T SA sur α1 , (sn , A, sn+1 ) ∈ ⇒, (sn+1 , B, sn+2 ) ∈ ⇒ et,
pour tout n + 2 ≤ i < m, (si , Ai+1 , si+1 ) ∈ ⇒. On montre alors qu’il existe s′ ∈ S V tel que
21
2. Le problème de synthèse et de contrôle distribués
E(B)
(sn , B, s′ ) ∈ ⇒ et (s′ , A, sn+2 ) ∈ ⇒. On définit s′ ∈ S V par s′E(B) = sn+2 et s′v = svn pour
E −1 (B)
tout v ∈ V \ E(B). Par définition (sn+1
E(B)
, sn+2 ) ∈ δB . Comme A I B, on a de plus que
E −1 (B)
E −1 (B)∩E(A) = ∅ et (sn , A, sn+1 ) ∈ ⇒ implique, par définition de δA , que sn+1
E −1 (B)
= sn
.
E −1 (B) ′E(B)
Donc (sn
,s
) ∈ δB , et (sn , B, s′ ) ∈ ⇒. Comme E −1 (A) ∩ E(B) = ∅, par définition
−1
−1
E (A)
de s′ , s′E (A) = sn
et comme E(A) ∩ E(B) = ∅, (sn+1 , B, sn+2 ) ∈ ⇒ implique que
−1
E(A)
E(A)
E(A)
E −1 (A) E(A)
sn+1 = sn+2 . Donc on obtient (s′E (A) , sn+2 ) = (sn
, sn+1 ) ∈ δA . Soit v ∈ V \ E(A).
′
′v
v
Si v ∈ E(B), par définition de s , s = sn+2 . Sinon, en utilisant le fait que (sn , B, s′ ) ∈ ⇒,
(sn , A, sn+1 ) ∈ ⇒ et (sn+1 , B, sn+2 ) ∈ ⇒, on obtient que s′v = svn+2 , et donc (s′ , A, sn+2 ) ∈ ⇒,
et α1 BAα2 = αi+1 ∈ L(A). Donc β ′ ∈ L(A). Ainsi on a montré que pour tout α′ préfixe fini
de longueur n de α, il existe β ′ préfixe fini de longueur m ≥ n de β tel que β ′ ∈ L(A). On
remarque par ailleurs que s’il existe deux mots β1 , β2 ∈ Σ′∗ tels que β1 est un préfixe de β2 ,
et β2 ∈ L(A), alors β1 ∈ L(A) et de plus, il existe une exécution de T SA sur β1 qui est un
préfixe de l’exécution de T SA sur β2 . Cette remarque nous permet de conclure que, pour tout
préfixe fini β ′ de β, β ′ ∈ L(A), et donc, qu’il existe, par passage à la limite, une exécution de
T SA sur β. Donc β ∈ L(A).
2.1.3
Spécifications.
Une spécification du système définit un sous-ensemble des exécutions du système : les
exécutions souhaitables. Elle sera souvent donnée sous une forme finie : automate sur les mots
représentant les exécutions, formule d’une logique temporelle dont les propositions atomiques
portent sur la valeur des états ou sont des égalités entre actions, etc.
Exemple 2.13 (Exemples de spécifications informelles). Pour l’architecture distribuée de
l’exemple 2.11, on peut envisager des spécifications demandant que soit respectées les différentes contraintes suivantes :
– « Toute action b mettant r1 à 1 est suivie par une action c »
– « Toute action a1 est suivie par une séquence bbca2 »
– « Le registre r4 vaut alternativement 0 et 1 »
– « À chaque fois que r1 = r2 , on peut atteindre un état dans lequel r4 = 0 ».
On fixe à présent une architecture distribuée A = (Σ, V, E, (S v )v∈V , s0 , ∆).
2.1.4
Programmes.
Un programme (ou contrôleur, ou stratégie) est une fonction non-déterministe F : (Σ′ ·
′
S V )∗ → 2Σ qui, en fonction de l’histoire de l’exécution propose le prochain groupe d’actions
à jouer. Ces programmes respectent l’architecture A, donc, pour chaque séquence d’actions
et d’états correspondant à une exécution possible de T SA , le programme ne propose que des
actions activables dans le dernier état visité. On appelle programme du système un programme
qui ne restreint que les actions contrôlables. Formellement, on définit les programmes du
système (ou stratégies du système) de la façon suivante :
′
Définition 2.14 (Programmes du système). On dit que F : (Σ′ · S V )∗ → 2Σ est un programme du système si, pour tout α = (A1 · s1 · · · Ai · si ) ∈ (Σ′ · S V )i , les conditions suivantes
22
Chapitre 2. Formalismes
sont vérifiées (avec si = s0 si α = ε) :
F (α) ⊆ en(si )
(2.2)
F (α) ∩ ΣN C = en(si ) ∩ ΣN C
(2.3)
On dit que le programme F est non-bloquant quand F ne peut proposer un ensemble vide
d’actions que si le dernier état visité est bloquant (si aucune action n’est activable dans cet
état).
′
Définition 2.15 (Programmes non-bloquants). On dit que F : (Σ′ · S V )∗ → 2Σ , programme
du système est un programme non-bloquant si, pour tout α = (A1 s1 · · · Ai si ) ∈ (Σ′ · S V )i , et
i ≥ 0 (avec si = s0 si α = ε),
si en(si ) 6= ∅ alors F (α) 6= ∅
(2.4)
Lorsque le système suit l’avis de la stratégie, l’ensemble des exécutions possibles de A
est restreint. On définit les exécutions suivant une stratégie F (ou exécutions F -compatibles)
comme étant les mots de Runs(A) formés des actions conseillées par la stratégie. Formellement,
Définition 2.16 (Exécution F -compatible). Une exécution selon la stratégie F (ou F compatible) est un mot α = s0 A1 s1 · · · ∈ S V · (Σ′ · S V )∞ tel que s0 est l’état initial de
A, A1 ∈ F (ε) et, pour tout i > 1, Ai ∈ F (A1 s1 · · · Ai−1 si−1 ).
On note RunsF (A) l’ensemble des exécutions F -compatibles de l’architecture A.
Remarque 2.17. Tels qu’ils sont définis, les programmes prennent leurs décisions basés sur une
exécution vue comme un mot. Donc, si L(A) est fermé par équivalence de traces, cela n’est
pas forcément le cas de RunsF (A).
On remarque également que, de la même façon que le préfixe d’une exécution est toujours
une exécution, tout préfixe d’une exécution F -compatible est une exécution F -compatible.
On introduit la notion de maximalité d’une exécution, qui indique lorsque l’exécution est
« terminée » en un certain sens, c’est-à-dire, lorsqu’elle est infinie, ou lorsque la stratégie
ne propose plus d’actions contrôlables. En effet, la stratégie proposant toujours toutes les
actions incontrôlables possibles, on laisse la possibilité à l’environnement de n’effectuer qu’un
nombre fini d’actions et donc une exécution dans laquelle la stratégie restreinte aux actions
du système n’est plus définie, peut être terminée. Par ailleurs, si après une séquence finie
d’actions, la stratégie propose encore des actions contrôlables, on considère que l’exécution
n’est pas terminée : si l’environnement ne joue plus, alors une action contrôlable sera effectuée.
On définit formellement les exécutions maximales comme suit.
Définition 2.18 (Exécution F -maximale). Pour toute stratégie du système F : (Σ′ · S V )∗ →
′
2Σ , on dit qu’une exécution F -compatible α = s0 α′ ∈ S V · (Σ′ · S V )∞ avec s0 ∈ S V état initial
de A et α′ ∈ (Σ′ · S V )∞ , est F -maximale si α ∈ S V · (Σ′ · S V )ω ou si F (α′ ) ∩ ΣC = ∅.
On note l’ensemble des exécutions F -maximales de A : Runsmax
F (A) ⊆ RunsF (A).
23
2. Le problème de synthèse et de contrôle distribués
2.1.5
Arbres d’exécutions
Les exécutions du système peuvent être représentées par un arbre t : Σ′ ∗ → S V donnant
les différentes exécutions de A possibles : pour chaque nœud α ∈ Σ′∗ , l’étiquette du nœud
t(α) donne l’état courant du système, et ce nœud a un successeur par action globale activable
dans cet état. Formellement,
Définition 2.19 (Arbre d’exécutions). Un arbre t : Σ′ ∗ → S V est un arbre d’exécution de A
si
– t(ε) = s0
– pour tout α ∈ Σ′ ∗ , si α ∈ dom(t) et t(α) = s ∈ S V , alors l’ensemble {A ∈ Σ′ | α · A ∈
dom(t)} = en(s) et, pour tout A ∈ en(s), t(α · A) = s′ avec (s, A, s′ ) ∈ ⇒.
Si A est non-déterministe, on peut avoir plusieurs arbres d’exécutions de A. On appelle
RunTrees(A) l’ensemble des arbres d’exécutions de A.
Soit F : (Σ′ ·S V )∗ → Σ′ une stratégie du système A. Un arbre d’exécutions selon la stratégie
F est un arbre d’exécutions dans lequel le branchement a été restreint : pour chaque nœud,
on ne considère que les actions autorisées par la stratégie à cet instant. Pour t : Σ′ ∗ → S V , on
définit la fonction Val(t) : Σ′ ∗ → (Σ′ ·S V )∗ qui associe à toute branche finie de t représentant un
mot fini de L(A) l’exécution de T SA correspondante (privée de l’état initial). Formellement,
pour tout α ∈ Σ′∗ ,
Val(t)(ε) = ε
Val(t)(α · A) = Val(t)(α) · A · t(α · A)
′
Définition 2.20 (Arbre d’exécutions selon une stratégie). Soit F : (Σ′ · S V )∗ → 2Σ une
stratégie du système A. Un arbre tF : Σ′ ∗ → S V est un arbre d’exécutions selon F si
– tF (ε) = s0
– pour tout α ∈ Σ′ ∗ , si α ∈ dom(tF ) et tF (α) = s ∈ S V , alors l’ensemble {A ∈ Σ′ |
α · A ∈ dom(tF )} = F (Val(tF )(α)) et, pour tout A ∈ F (Val(tF )(α)), tF (α · A) = s′ avec
(s, A, s′ ) ∈ ⇒.
Les arbres d’exécutions selon une stratégie F sont donc des sous-arbres des arbres d’exécutions du système. Pour une stratégie F fixée, on note RunTreesF (A) l’ensemble des arbres
d’exécutions selon F .
2.1.6
Le problème de synthèse de contrôleurs.
On peut à présent définir le problème de synthèse de contrôleurs : étant données une
architecture A et une spécification ϕ, existe-t-il un programme F du système tel que l’ensemble
des exécutions F -compatibles et F -maximales de A est inclus dans l’ensemble des exécutions
acceptables défini par la specification ϕ ? Si un tel programme existe, peut-on le produire
automatiquement ? On dira dans ce cas que F est un programme distribué vérifiant (ou
une stratégie distribuée gagnante pour) (A, ϕ). Par ailleurs, si pour une architecture fixée,
le problème est indécidable, on dira que l’architecture elle-même est indécidable (pour la
variante du problème considérée).
En ne considérant que des variables et des actions, ce modèle fait abstraction de la notion
de processus. Pour plus de clarté, nous allons faire réapparaı̂tre cette notion par la suite. Un
processus est simplement un ensemble de registres. On considère que l’ensemble des processus
24
Chapitre 2. Formalismes
forme une partition de l’ensemble des variables, donc qu’une variable ne peut pas faire partie
de deux processus distincts.
Par ailleurs, la façon dont nous avons défini un contrôleur pour un système ne tient pas
compte de l’aspect distribué de ce dernier : il prend ses décisions en fonction de l’état global
du système. Une approche plus intéressante est de chercher à synthétiser des contrôleurs qui
respectent l’architecture. Il y a plusieurs façons de formaliser cette intuition ; nous allons
maintenant en présenter quelques unes. Les principaux paramètres envisagés concernent la
façon de distribuer les stratégies, le type de mémoire autorisée pour ces stratégies, et la
façon de se donner la spécification. Par ailleurs, le problème de contrôle distribué implique
que les processus peuvent se transmettre de l’information entre eux. La modélisation des
communications autorisées est également un paramètre du problème. On va en distinguer
principalement deux : le formalisme dans lequel un processus peut lire certains registres d’un
autre (ce qu’on va appeler communication par variables partagées), et celui dans lequel il
peut connaı̂tre certaines actions effectuées par un autre (qu’on va appeler communication
par synchronisation d’actions). Enfin, deux types d’exécutions ont été envisagées pour les
systèmes : les exécutions totalement synchrones, et les exécutions asynchrones.
2.2
Comportement synchrone
Dans un système à comportement synchrone, on considère qu’il existe une horloge globale
réglant l’avancement de tous les composants du système. On exécute donc plusieurs actions
de Σ de façon simultanée.
2.2.1
Caractéristiques du problème en sémantique synchrone
Communication par variables partagées On note
U Proc l’ensemble des processus et on
partitionne les variables en sous-ensembles Vp , V = p∈Proc Vp tels que Vp est l’ensemble des
registres constituant le processus p. Dans ce modèle, la communication entre processus se fait
par variables partagées. Les actions sont toutes locales à un seul processus, dans le sens où
elles ne modifient les registres que d’un processus : pour tout a ∈ Σ, il existe p ∈ Proc tel que
E(a) ⊆ Vp . Pour tout p ∈ Proc, on note Σp = {a ∈ Σ | E(a) ⊆ Vp }. Les variables modifiées
par les actions incontrôlables du système forment un processus particulier, penv , représentant
l’environnement. On note ProcS = Proc \ {penv } l’ensemble des processus contrôlables du
système. Un processus p peut donc lire certaines variables écrites par d’autres en fonction du
domaine de lecture des actions de Σp . Pour simplifier, on considère que, pour tout p ∈ Proc,
pour tout a, b ∈ Σp , E −1 (a) = E −1 (b) et E(a) = E(b), et on identifie les variables en lecture
et en écriture d’un processus en fonction de ses actions : E −1 (p) = E −1 (a) et E(p) = E(a)
pour a ∈ Σp .
On se place dans un contexte d’environnement maximal, donc on impose que toutes les
actions incontrôlables soient proposables à chaque instant.1 . On rappelle que les transitions
associées aux actions de Σ sont déterministes (ceci afin de donner suffisamment de pouvoir
aux programmes lorsqu’ils choisissent leurs actions). Cette restriction choisie par rapport au
modèle plus général de [Zie87], qui autorisait des transitions non-déterministes nous impose
de considérer un grand nombre d’actions. En particulier, les actions incontrôlables du système
doivent permettre d’effectuer n’importe quelle transition. Dans ce modèle, cela revient à dire
1
Le problème de synthèse de contrôleur interagissant avec un environnement réactif a été traité par exemple
dans [KMTV00].
2. Le problème de synthèse et de contrôle distribués
25
qu’à chaque instant l’environnement peut écrire n’importe quelle valeur sur les variables qu’il
−1
contrôle : on demande donc que pour tout s ∈ S V , ΣN C ⊆ en(s) et, pour tout s ∈ S E (penv ) ,
pour tout s′ ∈ S E(penv ) , il existe une action incontrôlable a ∈ ΣN C telle que δa (s) = s′ .
Les variables d’un processus p ∈ ProcS se divisent en deux catégories : ses variables privées,
et ses variables de communication (i.e. lues par un autre processus). Comme on peut choisir
pour une variable donnée un domaine arbitrairement grand, on peut, sans perte de généralité,
supposer que chaque processus n’a qu’une seule variable privée, vp , lue et modifiée par le
processus p, et représentant son état de contrôle. Formellement, il existe un sous-ensemble
des variables {vp | p ∈ Proc} ⊆ V tel que pour tout p ∈ ProcS , cette variable est à la fois lue
et modifiée par le processus p : vp ∈ (E(p) ∩ E −1 (p)) et cette variable n’est lue ni modifiée
par aucun autre processus : pour tout p′ ∈ Proc tel que p′ 6= p, vp ∈
/ E(p) ∪ E −1 (p). On note
Com l’ensemble des variables de communication du système : Com = V \ {vp | p ∈ ProcS },
In(p) = E −1 (p) ∩ Com l’ensemble des variables lues par le processus p ∈ ProcS en dehors
de son état de contrôle, et Out(p) = E(p) ∩ Com l’ensemble des variables qu’il modifie. On
peut donc réécrire, pour chaque action a ∈ Σp la fonction de transition de la façon suivante :
δa : S vp × S In(p) → S vp × S Out(p) .
On appelle graphe d’une architecture le graphe formé par les relations entre actions contrôlables et variables de communication : (ΣC ⊎ Com, E ∩ (Com × ΣC ∪ ΣC × Com)). C’est une
restriction du graphe représentant la signature du système, puisqu’on rappelle que pour une
architecture distribuée A ayant pour ensemble d’actions Σ = ΣC ⊎ ΣN C et ensemble de variables V = ⊎p∈ProcVp , la relation E ⊆ (Σ × V ) ∪ (V × Σ). Or, ici ΣC ( Σ et Com ( V . On
appelle architecture acyclique une architecture dont le graphe est acyclique. En particulier,
dans une architecture acyclique, les actions associées à un processus ne dépendent pas des
variables du processus - à l’exception de son état de contrôle. Pour représenter une architecture, on dessinera uniquement son graphe de communications, dans lequel on assimilera les
actions de Σp et le processus p ∈ ProcS (voir figure 2.2). On a supprimé de cette définition de
graphe de communication les états de contrôle et les actions incontrôlables. En fait, même si
les états de contrôle et les actions incontrôlables induisent des cycles dans la signature initiale,
on verra dans la définition des exécutions (plus particulièrement dans la remarque 2.23) que
ces cycles n’induisent jamais de dépendance cyclique.
Exemple 2.21. La signature représentée sur la figure 2.1 ne peut donner lieu à une architecture distribuée respectant les contraintes que l’on vient de donner. En effet, tout d’abord
l’environnement n’est pas maximal : les actions qu’il peut effectuer dépendent de l’état global
du système, et les valeurs des variables écrites par les actions incontrôlables ne sont pas toutes
possibles. De plus, la variable r1 est modifiée par des actions ne pouvant appartenir au même
processus, puisque a1 est incontrôlable quand b l’est. Considérons par exemple la signature
suivante :
Σ = {a1 , a2 , a3 , a4 , b1 , b2 , b3 , c1 , c2 }
V = {r1 , r2 , r3 , r4 , r3′ , r4′ , vp , vq }
avec ΣN C = {a1 , a2 , a3 , a4 }, pour laquelle la relation E est représentée sur la figure 3.1(a).
On a ici Proc = {penv , p, q} définissant la partition de V : Vpenv = {r1 , r2 }, Vp = {r3 , r3′ , vp },
et Vq = {r4 , r4′ , vq }. On a également Σpenv = ΣN C = {a1 , a2 , a3 , a4 }, Σp = {b1 , b2 , b3 } et
Σq = {c1 , c2 }. On a donc Com = {r1 , r2 , r3 , r4 , r3′ , r4′ }, et par exemple In(p) = {r1 } et Out(p) =
{r3 , r3′ }. Le graphe de l’architecture associée est donc formé des nœuds {b1 , b2 , b3 , c1 , c2 } et
26
Chapitre 2. Formalismes
{r1 , r2 , r3 , r4 , r3′ , r4′ }. On a représenté sur la figure 3.1(b) le graphe de communication correspondant. N’apparaissent dans le graphe de communication représenté que les informations
« publiques ». Les actions Σp d’un processus p et son état de contrôle ne sont pas accessibles
aux autres processus, elles sont donc assimilées au processus p vu comme une « boı̂te noire ».
Seules ses variables Out(p) sont visibles. De même, on ne représente pas le cycle constitué par
les variables en lecture et en écriture de penv mais on représente les variables de E(penv ) avec
un arc entrant, et celles de E −1 (penv ) avec un arc sortant.
Délai des processus On pourra considérer qu’un délai peut intervenir dans la transmission
des valeurs entre processus, i.e., qu’un processus ne peut pas lire la valeur courante d’une
variable d’un autre processus, mais uniquement celle qui a été écrite k instants auparavant.
On associe donc à chaque processus un entier correspondant à cet intervalle de temps. Dans la
littérature, seuls les délais 0 ou 1 ont été considérés. Pour ne pas alourdir la présentation, nous
allons également considérer que la transmission est soit instantanée (0-délai), soit avec délai
de 1 (1-délai). On présente au chapitre 3 un modèle et des résultats permettant de considérer
des délais arbitraires sur les processus. Pour le moment, pour p ∈ ProcS , on note dp ∈ {0, 1}
son délai d’accès à l’information. On considère que l’environnement a toujours un délai de 0.
Le délai associé à un processus s’exprime dans la transition d’une action, comme on va le voir
dans le paragraphe suivant.
Exécutions À chaque instant de l’exécution, chaque processus choisit une action à exécuter,
et c’est la combinaison de toutes ces actions locales qui est jouée.
On définit donc les actions effectuées par le système en une unité de temps par Σ′ =
{A ∈ 2Σ | ∀p ∈ Proc, |Σp ∩ A| = 1}. Pour tout A ∈ Σ′ , on note A(p) l’élément de Σp ∩ A. On
remarque que D = (Σ′ )2 donc dans le cas synchrone, les traces de Mazurkiewicz de R(Σ′ , D) se
−1
confondent avec les mots de Σ′∞ . Soit A ∈ Σ′ , on définit δA ⊆ S E (A) × S E(A) par l’ensemble
−1
{(s1 , s2 ) ∈ S E (A) × S E(A) } vérifiant
E(penv )
s2
E(p)
s2
E −1 (penv )
= δA(penv ) (s1
=
v
In(p)
δA(p) ((s1p , s2−dp ))
)
(2.5)
pour tout p ∈ ProcS
(2.6)
L’effet de l’action choisie par le processus contrôlable p ∈ ProcS dépend de la valeur de
son état de contrôle à l’instant précédent, et de la valeur de ses variables en lecture au même
instant d’exécution si le processus est 0-délai, et à l’instant précédent s’il est 1-délai.
Remarque 2.22. On remarque que pour exprimer des délais plus importants que 1, il est
E(p)
dépend
nécessaire de modifier un peu le modèle général : en effet, la valeur de l’état local si
E −1 (p)
de l’état local si−dp . Lorsque le délai est inférieur ou égal à 1, il suffit pour déterminer le
prochain état atteint lors d’une transition de connaı̂tre la valeur de l’état courant. Cependant,
si le délai est strictement supérieur à 1, la valeur du prochain état est déterminé par des états
locaux plus anciens. On a donc besoin de considérer qu’un état de T SA est un tuple d’éléments
de S V : (S V )D où D = max(1, maxp∈ProcS {dp }) : pour calculer une transition, on a besoin
de connaı̂tre la valeur de l’état courant (pour mettre à jour le registre des processus p, vp ), et
la valeur de l’état le plus ancien sur lequel peut s’appliquer une action de A ∈ Σ′ . En effet,
si s0 A1 s1 A2 s2 ∈ S V · (Σ′ · S V )2 est une exécution de T SA , soit p ∈ ProcS tel que dp = 2,
v
In(p)
E(p)
alors s2
= δA2 (p) (s1p , s0 ). Une transition de T SA est donc dans ce cas-là de la forme
(s0 s1 , A2 , s1 s2 ), et on a besoin de considérer qu’un état global est un élément de (S V )2 .
27
2. Le problème de synthèse et de contrôle distribués
r3
b1
a1
r1
p
b2
a2
b3
penv
r3′
vp
a3
c1
r2
vq
q
a4
c2
(a) Un exemple de signature
p
r1
r3′
r2
r3
r4′
q
r4
(b) Le graphe de l’architecture
Fig. 2.2 – Une architecture distribuée dans le modèle synchrone
r4′
r4
28
Chapitre 2. Formalismes
Remarque 2.23. Si l’architecture distribuée A est acyclique, ou si les processus de A sont tous
à délai, les relations δA sont en fait des fonctions déterministes. On voit à présent que l’effet des
actions des processus ne dépend de la valeur de leur état de contrôle qu’à l’instant précédent,
le cycle que ces registres constituent dans le graphe n’induit donc pas de non-déterminisme.
C’est pour la même raison qu’on n’inclut pas non plus les actions de l’environnement dans la
définition du graphe de communication, et donc d’une architecture acyclique.
Exemple 2.24. Reprenons la signature de l’exemple 2.21, dans laquelle on suppose que
tous les processus sont 0-délai. On pose S v = {0, 1} pour tout v ∈ V . On pose également
δa1 (s) = (1, 1) pour tout s ∈ S r3 ,r4 et
δb1 : r1 r4′ vp r3 r3′ vp δc1 : r2 r3′ vq r4 r4′ vq
1 1
0
0 0
1
1 1 0
0 0 1
0 1
1
0 1 1
1 0
0
1 0 0
0 1
0
0 1 0
1 1
1
1 1 1
1 0
1
1 0 1.
0 0
0
0 0 0
Soit l’action A = (a1 , b1 , c1 ) ∈ Σ′ . Alors, d’après les égalités (2.5) et (2.6), pour s1 ∈
−1
S E (A) défini par, pour tout v ∈ V , sv1 = 0, il existe s2 , s′2 ∈ S V tels que (s1 , s2 ) et (s1 , s′2 ) ∈
δA :
δA :
r1 r2 r3 r4 r3′ r4′ vp vq r1 r2 r3 r4 r3′ r4′ vp vq
(s1 , s2 ) 0 0 0 0 0 0 0
0
1 1 0 0 1 0 1
1
0
(s1 , s′2 ) 0 0 0 0 0 0 0
1 1 0 0 0 1 1
1
Si par contre, les délais des processus p et q sont à 1, alors la fonction δA est déterministe.
Programmes Par la suite on va considérer que en(s) ∩ Σp 6= ∅ pour tout état s ∈ S V et
tout processus p ∈ Proc, c’est-à-dire qu’un processus n’est jamais bloqué. Comme par ailleurs
on se restreint aux programmes non-bloquants du système, la condition (2.4) implique que
pour tout α ∈ S V · (Σ′ · S V )∗ , F (α) ∩ ΣC 6= ∅, et donc que les exécutions F -maximales (voir
définition 2.18) sont toutes infinies.
De plus, on s’intéresse aux contrôleurs distribués parmi les processus. On dit qu’un pro′
gramme F : (Σ′ · S V )∗ → 2Σ est distribué parmi les processus s’il existe un tuple de strap
tégies locales, f p : (Σ′ · S V )∗ → 2Σ pour tout p ∈ Proc tel que, pour tout α ∈ (Σ′ · S V )∗ ,
F (α) = {A ∈ Σ′ | ∀p ∈ Proc, A(p) ∈ f p (α)}. On se restreint de plus à des programmes
déterministes pour les processus du système, i.e., pour tout p ∈ ProcS , f p : (Σ′ · S V )∗ → Σp .
La difficulté du contrôle de systèmes distribués vient du fait que chaque contrôleur n’a
qu’une vision locale de l’état du système. On modélise cette contrainte par le fait que l’on
demande que les stratégies des processus soient à mémoire locale, i.e., le programme de chaque
processus ne peut tenir compte de toute l’histoire globale du système, mais uniquement de
l’histoire sur les variables qu’il peut lire. Formellement, on impose aux stratégies de respecter
la condition suivante :
Définition 2.25 (Stratégie à mémoire locale). On dit que la stratégie f p du processus p ∈
Proc est à mémoire locale si, pour tous α = A1 s1 · · · Ai si , α′ = A′1 s′1 · · · A′i s′i ∈ (Σ′ × S V )i ,
tels que
−1
−1
(s1 · · · si )E (p) = (s′1 · · · s′i )E (p)
on a
f p (α) = f p (α′ ).
29
2. Le problème de synthèse et de contrôle distribués
On dit que la stratégie distribuée F = (f p )p∈Proc est à mémoire locale si pour tout p ∈ ProcS ,
f p est à mémoire locale.
Remarque 2.26. La contrainte (2.2) impose que pour tout p ∈ Proc, tout α = A1 s1 · · · Ai si ∈
−1
(Σ′ · S V )∗ , f p (α) ⊆ en(si ), avec si = s0 si α = ε. Or, pour tout s, s′ ∈ S V tels que sE (p) =
−1
s′ E (p) , en(s) ∩ Σp = en(s′ ) ∩ Σp , donc cette contrainte ne dépend que de la vision locale de
la stratégie.
De plus, comme le système est non-bloquant et l’environnement est maximal, les conditions
(2.2), (2.3) et (2.4) peuvent se réécrire au niveau local de la façon suivante : pour tout
α = A1 s1 · · · Ai si ∈ (Σ′ · S V )∗ , avec si = s0 si α = ε
f p (α) ⊆ en(si ) ∩ Σp
f
penv
pour tout p ∈ ProcS
(α) = en(si ) ∩ ΣN C = ΣN C
(2.7)
(2.8)
p
pour tout p ∈ ProcS
f (α) définie
(2.9)
Spécifications Dans ce modèle de communication par variables partagées, les spécifications
vont porter sur les séquences d’états du système visités au cours d’une exécution. Par la suite,
on va considérer plus précisément des spécifications données par des formules logiques, typiquement des formules de LTL, CTL, CTL∗ , µ-calcul ou MSO. Plusieurs types de spécifications
ont été abordées dans la littérature :
– les spécifications dites externes, qui ne portent que sur les variables de communication
avec l’environnement (i.e., lues et modifiées par le processus environnement)
– les spécifications locales, qui ne relient des valeurs de variables que si elles sont en lecture
ou en écriture d’un même processus
– les spécifications totales, les plus générales, qui peuvent contraindre l’ensemble des valeurs des variables du système de façon non restreinte.
xp′
xp
p
yp
t
p′
yp′
zp′
Fig. 2.3 – Exemple d’architecture
Exemple 2.27 (Exemples de spécifications informelles). Considérons l’architecture représentée sur la figure 2.3, dans laquelle on respecte encore la convention que les variables écrites
par l’environnement sont représentées avec un arc entrant, et les variables lues par l’environnement avec un arc sortant. Par exemple, la variable zp′ est une variable du processus p′ qui
n’est lue par aucun processus. On peut choisir d’exprimer les contraintes suivantes :
30
Chapitre 2. Formalismes
Spécifications externes
1. À chaque instant, xp = yp et xp′ = yp′
2. À chaque instant, xp = yp′
3. À chaque instant, si xp = xp′ alors yp = yp′
Spécifications locales
1. À chaque instant, xp = yp et xp′ = yp′
2. À chaque instant, xp = t et t = yp′
3. À chaque instant, si t = xp′ alors yp′ = zp′
1. À chaque instant, xp = yp et xp′ = yp′
2. À chaque instant, xp = yp′ et t = 0
3. À chaque instant, si xp = xp′ alors yp = yp′
Les deuxième et troisième spécifications externes ne sont pas des spécifications locales : on
ne peut pas lier deux variables qui ne sont pas connectées au même processus. Par contre, on
peut exprimer de façon équivalente pour le problème de contrôle la deuxième spécification par
une spécification locale faisant intervenir la variable de communication t. Réciproquement,
la troisième spécification locale n’est pas une spécification externe, car d’une part elle fait
intervenir une variable de communication, t, et d’autre part, elle restreint une variable qui
n’est pas une variable de sortie, mais une variable du processus p′ qui lui est privée. La
deuxième spécification totale n’est ni une spécification externe (elle contraint la variable de
communication t, en l’empêchant de transmettre de l’information), ni une spécification locale
(elle relie deux variables qui ne sont reliées à aucun processus en commun).
Spécifications totales
Formellement, on note respectivement VI = E(ΣN C ) et VO = {v ∈ V | E(v) = ΣN C } les
variables d’entrée et de sortie du système. Soit U ⊆ V un sous-ensemble des variables. Pour
L ∈ {LTL, CTL, CTL∗ , µ-calcul, MSO}, on note L(U ) l’ensemble des fomules de L utilisant des
propositions atomiques AP de la forme (v = a) pour v ∈ U et a ∈ S v . Un mot σ = s0 s1 · · · ∈
(S V )ω est donc assimilé à une séquence u : N → (2AP ) dans laquelle, pour tout v ∈ U , a ∈ S v ,
(v = a) ∈ u(i) si et seulement si svi = a.
Remarque 2.28. Si ϕ ∈ L(U ) avec U ⊆ V , soit σ ∈ (S V )ω un modèle de ϕ. Alors σ |= ϕ si et
seulement si σ U |= ϕ.
Une spécification est dite externe si elle appartient à L(VI ∪ VO ). Elle est dite locale si elle
s’obtient par combinaison booléenne de formules dans L(E −1 (p) ∪ E(p)) pour tout p ∈ Proc.
Sinon elle est dite totale.
Pour déterminer si une exécution du système satisfait la spécification ϕ ∈ L(U ), on va
définir Spec(ϕ) ⊆ S V · (Σ′ · S V )ω .
Pour ϕ formule de temps linéaire, on définit Spec(ϕ) = {α ∈ S V ·(Σ′ ·S V )ω | πS V (α) |= ϕ},
i.e, l’ensemble des exécutions (infinies, car le problème de synthèse se restreint à des exécutions
F -maximales pour un programme F fixé) qui visitent une séquence d’états qui est un modèle
de ϕ.
Pour ϕ formule branchante, on définit Spec(ϕ) = {t : Σ′ ∗ → S V | t |= ϕ}, i.e., l’ensemble
des arbres (qu’on comparera avec les arbres d’exécutions selon une stratégie F donnée) qui
sont modèles de ϕ.
La synthèse de contrôleur en comportement synchrone Le problème de synthèse
se distingue du problème de contrôle par le fait que dans le premier cas, aucun programme
n’existe. Cela signifie que chaque processus ne comporte qu’un seul état de contrôle à partir
31
2. Le problème de synthèse et de contrôle distribués
duquel toutes les actions sont toujours possibles. Formellement, lorsque l’architecture A est
telle que pour tout p ∈ ProcS ,
– |S vp | = 1, i.e., il n’y a qu’un seul état de contrôle,
E −1 (p)
telle que, pour tout a ∈ Σp ,
– il existe une application bijective δp : Σp → (S E(p) )S
δ(a) = δa , i.e., pour tous les processus du système, toutes les actions possibles sont
toujours activables (les actions incontrôlables sont toutes possibles et activables car on
considère un environnement maximal, comme expliqué au début de la section 2.2.1),
on dit que A est une architecture à synthétiser. Dans les autres cas, on dit que A est une
architecture à contrôler.
Définition 2.29 (Le problème de synthèse (respectivement de contrôle) de système distribué
synchrone, avec spécifications externes (respectivement locales, totales)). Étant donnés
– une architecture A = (Σ, V, E, (S v )v∈V , s0 , (δa )a∈Σ ) à synthétiser (respectivement à
contrôler),
– un ensemble Proc, contenant un élément particulier penv , partitionnant les variables
– un tuple (dp )p∈Proc donnant les délais de chaque processus,
– une spécification externe (respecivement locale, totale) ϕ,
existe-t-il une stratégie distribuée non-bloquante F = (f p )p∈Proc à mémoire locale telle que
l’ensemble des exécutions F -maximales Runsmax
F (A) ⊆ Spec(ϕ) ? Si ϕ est une formule branchante, existe-t-il F = (f p )p∈Proc stratégie distribuée non-bloquante et à mémoire locale telle
que RunTreesF (A) ⊆ Spec(ϕ)?
Lorsque, pour tout p ∈ ProcS , dp = 0 on dit que l’architecture est 0-délai. Lorsque, pour
tout p ∈ ProcS , dp = 1, on dit que l’architecture est 1-délai.
Remarque 2.30. Comme on l’a dejà relevé dans la remarque 2.23, lorsque l’architecture est
acyclique ou 1-délai, les fonctions δA sont déterministes. Comme les stratégies que l’on cherche
sont également déterministes pour les processus du système ProcS , le choix fait au début
de la section de se restreindre à des actions a ∈ Σ déterministes a la conséquence que,
en choisissant un tuple d’actions, la stratégie peut prévoir leur effet sur les variables du
système. Formellement, si l’on fixe une séquence d’actions de l’environnement αenv ∈ ΣωN C ,
alors il existe une unique exécution F -compatible α ∈ S V · (Σ′ · S V )ω , telle que, si on note
πΣ′ (α) = A1 A2 · · · , alors A1 (penv )A2 (penv ) · · · = αenv .
2.2.2
Quelques résultats de la littérature
Le problème de synthèse de système centralisé est un cas particulier de synthèse de systèmes distribués dans lequel |ProcS | = 1. Dans ce cas, les spécifications totales et locales
sont équivalentes, et, si l’on suppose que toutes les variables sont lues par l’environnement,
équivalentes aux spécifications externes. Historiquement, le problème de synthèse de système
centralisé synchrone avec des spécifications données par des formules dans MSO(V ) a été posé
par Church dans [Chu63], et a été résolu pour la première fois dans [BL69], puis dans [Rab72].
Plus récemment, [PR89a] (voir aussi [Ros92]) a proposé un formalisme moderne, avec des spécifications LTL, et donne une solution plus simple au problème (avec une meilleure complexité).
Dans notre modèle, certaines variables de l’environnement peuvent être invisibles pour le processus contrôlable (elles ne font pas partie de son domaine de lecture), et cependant prises en
compte dans la spécification. Cette notion d’information incomplète est d’ailleurs un premier
pas vers la résolution du problème de synthèse ou de contrôle de systèmes distribués, puisque
32
Chapitre 2. Formalismes
xP1
xP2
P1
P2
y P1
y P2
Fig. 2.4 – Architectures A0 indécidable
dans ce dernier cas, le programme que l’on cherche à synthétiser pour le processus, étant à
mémoire locale, a une information seulement partielle de l’état global du système.
On dit donc que le problème de contrôle (ou de synthèse) pour (A, ϕ) est à information
incomplète s’il existe v ∈ V , p ∈ ProcS , tels que v ∈
/ E −1 (p). Sinon, il est à information
complète.
Il est donc clair qu’en général, lorsque |ProcS | > 1, le problème est à information incomplète. Le problème de synthèse avec information incomplète a été traité dans [KV97], qui a
également étendu les résultats de [PR89a] aux spécifications branchantes. (Une version complète des résultats de [KV97] a été publiée dans [KV99]). On peut donc établir les résultats
suivants :
Théorème 2.31 ([PR89a, Ros92]). Le problème de synthèse de système centralisé synchrone
avec information complète est décidable, et 2EXPTIME-complet, pour des architectures 0délai et des spécifications dans LTL(V ).
Théorème 2.32 ([KV99, KV00]). Le problème de synthèse de système centralisé synchrone
avec information incomplète est décidable pour des architectures 0-délai, et est EXPTIMEcomplet pour des spécifications dans CTL(V ) et du µ-calcul, et 2EXPTIME-complet, pour des
spécifications dans LTL(V ) et CTL∗ (V ).
Le cas général de synthèse de système distribué synchrone a été étudié pour la première
fois dans [PR90] (plus précisément la variante synthèse de système distribué synchrone sans
délai avec des spécifications externes). En s’inspirant de résultats de [PR79] sur les jeux
distribués, ils obtiennent l’indécidabilité de ce problème en général :
Théorème 2.33 ([PR90], adapté dans [FS05]). Le problème de synthèse de système distribué synchrone est indécidable avec spécifications externes et totales de LTL et CTL pour les
architectures 0-délai.
En fait, on verra au chapitre suivant qu’on peut adapter ce résultat à des architectures
ayant n’importe quels délais sur ses processus.
La preuve d’indécidabilité de [PR90] repose sur une réduction du problème de l’arrêt d’une
machine de Turing au problème de synthèse de systèmes distribués synchrone sans délai pour
une spécification ϕ ∈ LTL et l’architecture A0 suivante (voir figure 2.4) :
2. Le problème de synthèse et de contrôle distribués
33
V = {xP1 , yP1 , xP2 , yP2 , vP1 , vP2 }
Proc = {P1 , P2 , penv }
VP1 = {yP1 , vP1 }, VP2 = {yP2 , vP2 }
ΣC = {aP001 , aP101 , aP011 , aP111 , aP002 , aP102 , aP012 , aP112 }
env env env
ΣN C = {aenv
00 , a01 , a10 , a11 }
E = (ΣN C × {xP1 , xP2 }) ∪ ({yP1 , yP2 } × ΣN C )
∪ ({xP1 , vP1 } × {aP001 , aP101 , aP011 , aP111 }) ∪ ({aP001 , aP101 , aP011 , aP111 } × {yP1 , vP1 })
∪ ({xP2 , vP2 } × {aP002 , aP102 , aP012 , aP112 }) ∪ ({aP002 , aP102 , aP012 , aP112 } × {yP2 , vP2 })
S v = {0, 1} pour tout v ∈ Com
S vPi = {0} pour i = 1, 2
sv0 = 0 pour tout v ∈ V
δaenv
(s) = (i, j) pour tout s ∈ S E
ij
−1 (aenv )
ij
, avec i, j = 0, 1
δai (s)yPi = 0 pour tout s ∈ S
E −1 (ai00 )
, avec i = P1 , P2
δai (s)yPi = s pour tout s ∈ S
E −1 (ai01 )
, avec i = P1 , P2
00
01
δai (s)yPi = 1 − s pour tout s ∈ S
E −1 (ai10 )
10
δai (s)yPi = 1 pour tout s ∈ S E
11
−1 (ai )
11
, avec i = P1 , P2
, avec i = P1 , P2
dP1 = dP2 = 0
Ce théorème établit donc l’indécidabilité du problème de contrôle de systèmes distribués
synchrones en général. Cependant, il est possible d’identifier des cas particuliers pour lesquels
le problème est décidable : les travaux suivants ont donc cherché à définir pour quelles sousclasses d’architecture ou de spécifications le problème était décidable. Même si un certain
nombre de résultats positifs ont pu être obtenus, ces sous-classes restent assez restreintes. On
commence par décrire certaines classes d’architectures pour lesquelles des résultats ont été
prouvés (voir figure 2.5) :
Définition 2.34. Une architecture distribuée A = (Σ, V, E, (S v )v∈V , s0 , (δa )a∈Σ ) comportant
l’ensemble de processus Proc dans laquelle ProcS est isomorphe à {p1 , · · · , pn } est de type
– pipeline si
– In(p1 ) ⊆ VI
– pour tout 2 ≤ i ≤ n, In(pi ) ⊆ E(pi−1 ).
– anneau si
– In(p1 ) ⊆ (VI ∪ E(pn ))
– pour tout 2 ≤ i ≤ n, In(pi ) ⊆ E(pi−1 ).
– pipeline à double sens si
– In(p1 ) ⊆ (VI ∪ E(p2 ))
– In(pn ) ⊆ E(pn−1 )
– pour tout 2 ≤ i ≤ n − 1, In(pi ) ⊆ (E(pi−1 ) ∪ E(pi+1 )).
– anneau à double sens si
– In(p1 ) ⊆ (VI ∪ E(p2 ) ∪ E(pn ))
34
Chapitre 2. Formalismes
– In(pn ) ⊆ (E(p1 ) ∪ E(pn−1 ))
– pour tout 2 ≤ i ≤ n − 1, In(pi ) ⊆ (E(pi−1 ) ∪ E(pi+1 )).
– pipeline à double entrée si
– VI = V1 ⊎ V2
– In(p1 ) = V1
– In(pn ) ⊆ V2 ∪ E(pn−1 )
– pour tout 2 ≤ i ≤ n − 1, In(pi ) ⊆ E(pi−1 )
Le premier résultat de décidabilité a été prouvé dans [PR90] et établit la décidabilité du
problème de synthèse de système distribué synchrone avec spécifications externes de LTL pour
les architectures pipeline 0-délai. Plus tard, [KV01] ont étendu ce résultat en considérant des
spécifications totales de CTL∗ . Comme une spécification externe est aussi une spécification
totale, si le problème de synthèse de systèmes distribués est décidable pour une architecture
donnée avec des spécifications totales, il l’est aussi avec des spécifications externes. De plus,
CTL∗ étendant LTL, on établit le résultat plus général suivant :
Théorème 2.35 ([KV01]). Le problème de synthèse de système distribué synchrone avec
spécifications totales de CTL∗ est décidable en temps non-élémentaire pour les architectures
de type pipeline 0-délai ou 1-délai.
Cette complexité est également une borne inférieure, ceci découlant d’un résultat plus
ancien sur les jeux distribués [PR79]. On remarque qu’en fait ce théorème recouvre et étend
le théorème 2.32. Il nous donne donc également la décidabilité du problème de synthèse de
systèmes centralisés synchrones avec information incomplète pour des architectures 1-délai.
Par ailleurs, la preuve de décidabilité du pipeline de [KV01] s’étend également aux anneaux
et pipelines à double sens. D’où :
Théorème 2.36 ([KV01]). Le problème de synthèse de système distribué synchrone avec
spécifications totales de CTL∗ est décidable pour les architectures 1-délai de type anneau et
pipeline à double sens.
Toutes ces architectures décidables ont un point commun : l’information se transmet de
façon linéaire parmi les processus. L’approche de [KV01] a été reprise et étendue dans [FS05]
afin de montrer que cette caractéristique est en fait un critère de décidabilité du problème de
synthèse de système distribué synchrone.
Définition 2.37 (Architecture ordonnée). Une architecture est ordonnée si on peut totalement ordonner les processus de Proc par la relation définie par p ≤ q si et seulement si,
pour tout v1 ∈ VI , pour tout vq ∈ E −1 (q) et pour toute séquence v2 , . . . , vn−1 ∈ V telle que
v1 E 2 v2 E 2 . . . E 2 vn−1 E 2 vq il existe 1 ≤ i ≤ n tel que vi ∈ E −1 (p).
La valeur d’une variable lue par le processus q lui donne une certaine information sur ce
qu’a joué l’environnement, et par là, les stratégies des autres processus lui étant connues, lui
donne une connaissance partielle de l’état global. Ce que dit donc cette définition, c’est que si
toute information de l’environnement parvenant à q a d’abord « transité » par p, alors p ≤ q
dans le sens « p a une meilleure connaissance de l’état global que q ». Une architecture est
donc ordonnée si on ne peut pas trouver deux processus ayant une connaissance incomparable
de l’état global du système.
35
2. Le problème de synthèse et de contrôle distribués
x0
P1
x1
P2
...
Pn
xn
...
Pn
xn
Pn
xn
Pn
xn
(a) Pipeline
x0
P1
x1
P2
(b) Anneau
...
x1
x0
P1
P2
...
x′1
(c) Pipeline à double sens
x′′1
x0
P1
x1
...
P2
...
x′1
(d) Anneau à double sens
x′0
x0
P1
x1
P2
...
Pn
xn
(e) Pipeline à double entrée
Fig. 2.5 – Différentes classes d’architectures
36
Chapitre 2. Formalismes
x1
x2
p1
p2
x3
x4
p3
p4
x5
x6
Fig. 2.6 – Une architecture décidable pour des spécifications externes
Théorème 2.38 ([FS05]). Le problème de synthèse de système distribué synchrone avec spécifications totales du µ-calcul est décidable pour une architecture A 1-délai si et seulement si
A est ordonnée.
Ce critère permet de conclure à l’indécidabilité du problème de synthèse distribuée synchrone avec spécifications totales pour les pipelines à double entrée et les anneaux à double
sens à partir d’une certaine taille.
Comme on l’a vu, si le problème de synthèse de système distribué est décidable pour des
spécifications totales, il l’est pour des spécifications externes ou totales. Par contre, s’il est
indécidable pour des spécifications totales, il ne l’est pas forcément pour des spécifications
externes, le pouvoir d’expression supplémentaire des formules totales pouvant être trop fort –
par exemple [PR90] ont montré que le problème de synthèse de système distribué synchrone
avec spécifications externes pour l’architecture représentée figure 2.6 n’est pas plus difficile que
la synthèse de système centralisé synchrone, et donc décidable. Or cette architecture n’est pas
ordonnée au sens de la définition 2.37, les processus p1 et p2 ayant une connaissance incomparable de l’état global du système. Le théorème 2.38 assure donc que le problème de synthèse
de système distribué pour cette architecture et des spécifications totales est indécidable. Ce
critère de décidabilité n’est donc pas transposable aux autres types de spécifications. En particulier, [MT01] ont établi la décidabilité du problème pour les pipelines à double entrée si on
se restreint aux spécifications locales :
Théorème 2.39 ([MT01]). Le problème de contrôle de systèmes distribués synchrones avec
spécifications locales de LTL est décidable pour les architectures 0-délai de type pipeline à
double entrée.
Remarque 2.40. Le théorème 2.39 a en fait été établi par [MT01] pour des spécifications locales
de type Rabin portant sur les états locaux des processus, ce qui recouvre les spécifications
LTL. Par ailleurs, en posant V2 = ∅, on retrouve les pipelines de [PR90]. Le théorème 2.39
élargit donc d’une part la classe des architectures pour lesquelles le problème est décidable,
et étend d’autre part la décidabilité du pipeline avec spécifications locales au cas du contrôle.
2. Le problème de synthèse et de contrôle distribués
37
Cependant, le théorème suivant montre que même en considérant des spécifications locales, la classe d’architectures pour lesquelles le problème de contrôle de systèmes distribués
synchrones est décidable reste limitée. On commence par définir la notion de sous-architecture.
Soit G = (V, E) un graphe. On dit que G′ = (V ′ , E ′ ) est un sous-graphe de G si V ′ ⊆ V
et E ′ = E ∩ (V ′ × V ′ ).
Définition 2.41. Une architecture distribuée A′ est une sous-architecture de l’architecture
A si le graphe de A′ est isomorphe à un sous-graphe du graphe de A.
On peut maintenant établir :
Théorème 2.42 ([MT01]). Le problème de contrôle de systèmes distribués synchrones avec
des spécifications locales est décidable pour une architecture 0-délai A si et seulement si toutes
les composantes connexes du graphe de A sont des sous-architectures d’un pipeline à double
entrée.
Les résultats présentés ci-dessus avaient tous la caractéristique de se placer dans des cas
où les architectures étaient acycliques, ou 1-délai. Comme expliqué dans la remarque 2.23, les
fonctions δA sont donc des fonctions déterministes, pour tout A ∈ Σ′ . Dans un travail plus
récent, [BJ06] étudie le problème de synthèse de système distribué synchrone 0-délai, dans des
architectures comportant des cycles. Pour une même séquence d’actions de l’environnement,
il existe donc plusieurs exécutions compatibles avec une stratégie. Tel qu’exprimé actuellement, le problème de synthèse est très exigeant vis-à-vis de la stratégie : il faut que toutes
les exécutions compatibles avec la stratégies satisfassent la spécification. On peut envisager
d’autres interprétations d’une stratégie gagnante. On va donc paramétrer le problème par le
type strict, angélique ou démoniaque de la spécification (reprenant par là la terminologie de
[BJ06] : pour ϕ ∈ MSO(U ), on définit
Specstrict (ϕ) ={α ∈ S V · (Σ′ · S V )ω | il existe un unique α′ ∈ Runs(A), πΣ′ (α) = πΣ′ (α′ )
et πS V (α) |= ϕ}
Specangel (ϕ) ={α ∈ S V · (Σ′ · S V )ω | il existe α′ ∈ Runs(A), tel que πΣ′ (α) = πΣ′ (α′ )
et πS V (α′ ) |= ϕ}
Specdemon (ϕ) ={α ∈ S V · (Σ′ · S V )ω | pour tout α′ ∈ Runs(A) tel que πΣ′ (α) = πΣ′ (α′ )
πS V (α′ ) |= ϕ}
Le problème exprimé dans la définition 2.29 correspond aux spécifications strictes si l’on se
restreint aux architectures déterministes, et aux spécifications démoniaques sinon.
Ils obtiennent le résultat suivant :
Théorème 2.43 ([BJ06]). Le problème de synthèse de système distribué synchrone avec
spécifications totales de MSO strictes ou angéliques est décidable pour une architecture 0délai A si et seulement si A est ordonnée.
Le problème reste ouvert pour les interprétations démoniaques.
Dans toutes les variantes du problème énoncées ci-dessus, lorsque le problème est décidable,
alors il existe une stratégie gagnante pour une donnée (A, ϕ) si et seulement si il existe une
stratégie gagnante à mémoire finie pour (A, ϕ).
38
2.3
Chapitre 2. Formalismes
Comportement asynchrone
Dans un système à comportement asynchrone, les processus avancent à des vitesses variables, et se synchronisent de temps en temps pour communiquer. Un ordonnanceur permet
aux processus de s’exécuter. C’est dans le modèle asynchrone que la notion de trace de Mazurkiewicz comme représentation des exécutions prend tout son sens. En effet, dans un système
distribué asynchrone, un certain nombre d’actions peuvent avoir lieu sans que l’état d’une
partie des processus en soit affecté, ou pendant qu’un sous-ensemble des processus effectuent
d’autres actions qui n’ont pas d’effet sur les premières. Ceci est traduit par la notion d’actions
indépendantes de la théorie des traces. Une exécution vue comme une trace permet donc de
regrouper un ensemble d’exécutions équivalentes à ordonnancement près. Dans ce contexte,
un autre type de mémoire pour les contrôleurs a été envisagé : les contrôleurs à mémoire
causale. Si un contrôleur à mémoire locale ne dépend que de ce qu’il a lui-même observé (que
ce soit les variables des autres processus qu’il a eu l’occasion de lire, ou les actions auxquelles
il a participé), un contrôleur à mémoire causale par contre peut dépendre de toutes les actions
qui ont eu lieu dans son passé causal, i.e., les actions qui ont eu lieu dans son passé dans toutes
les linéarisations de la trace représentant l’exécution en cours.
2.3.1
Communication par variables partagées
Le modèle de communication par variables partagées lorsque l’on considère des systèmes
asynchrones signifie que les processus ne peuvent lire les variables des autres processus et
écrire sur leurs propres variables qu’aux instants décidés par l’ordonnanceur. En particulier,
dans une exécution asynchrone, un processus lisant des variables écrites par un autre n’a
aucun moyen de savoir combien de fois ce registre a été modifié depuis le précédent instant
où il y a eu accès.
Caractéristiques des architectures La classe d’architectures utilisée est similaire à celle
définie dans la section 2.2.1 pour les systèmes synchrones, avec les variations suivantes. Pour
tout processus p ∈ ProcS , on distingue les actions de lecture seule Σpr , les actions d’écriture
seule Σpw et les actions de lecture et écriture simultanées Σpm , avec Σp = Σpr ⊎ Σpw ⊎ Σpm .
Les actions de lecture seule permettent juste au processus de lire les variables auxquelles il a
accès, sans modifier les siennes (excepté son état de contrôle). Dans ce cas précis, pour a ∈ Σpr ,
E(a) = {vp }. Les actions d’écriture seule permettent d’écrire sur les variables du processus,
mais ne dépendent pas de la valeur courante des variables en lecture : E −1 (a) = {vp }. On
demande de plus que les actions de lecture et d’écriture soient alternées : pour tout processus
p ∈ ProcS , le domaine de son état de contrôle vp contient une composante indiquant si
la dernière action jouée a modifié les variables. Formellement, S vp = S × {R, W } pour S
domaine quelconque. Les fonctions de transitions locales respectent les restrictions suivantes :
Pour tout a ∈ Σpr , δa : S × {R} × S In(p) → S × {W }
Pour tout a ∈ Σpw , δa : S × {W } → S × {R} × S Out(p)
Pour tout a ∈ Σpm , δa : S × {R} × S In(p) → S × {R} × S Out(p)
v
s0p ∈ S × {R}
On dit qu’une architecture est à lecture et écriture alternées si les actions de Σpm ne sont
jamais autorisées : pour tout p ∈ ProcS , pour tout s ∈ S V , en(s) ∩ Σpm = ∅. On dit qu’elle
2. Le problème de synthèse et de contrôle distribués
39
est à lecture et écriture simultanées si les processus n’utilisent que des actions de lecture et
écriture simultanée, i.e., si, pour tout p ∈ ProcS , tout s ∈ S V , en(s) ∩ Σp ⊆ Σpm . Dans ce cas,
l’asynchronisme du système se traduit dans les exécutions du système de transitions associé
à A.
Exécutions Classiquement, dans une exécution asynchrone d’un système distribué, on
considère qu’à chaque transition de T SA , une seule action est exécutée. La concurrence possible entre deux actions effectuées par deux processus est capturée par la notion de trace
de Mazurkiewicz. Dans ce modèle, Σ′ = Σ et donc les transitions locales considérées sont
celles données dans la définition du système distribué, ∆ (et dans ce cas, notre définition
d’exécution d’un système rejoint la définition classique des exécutions linéarisées des automates de [Zie87]). Une autre approche des exécutions asynchrones, a été choisie dans [FS06],
reprenant l’idée de modélisation de [MW03] pour les jeux distribués adaptés à la synthèse.
Dans ce modèle, on conserve la notion d’horloge globale et, à chaque instant, l’ordonnanceur autorise certains processus (ou aucun) à s’exécuter. L’asynchronisme est modélisé par
le fait qu’un processus ne connaı̂t pas la relation entre son évolution et celle de l’horloge
globale. La notion d’actions concurrentes n’est pas explicitement rendue, et on considère
plutôtSla simultanéité éventuelle, mais non garantie, de certains processus. Dans ce cas,
Σ′ = P ∈2Proc \∅ {A ∈ 2Σ | ∀p ∈ P, |A ∩ Σp | = 1}. Par la suite on dira que ce modèle est
un modèle d’exécutions pseudo-synchrones, et on considérera que toutes les architectures sont
1-délai (afin de n’avoir que des architectures déterministes).
Stratégies On s’intéresse aux stratégies distribuées parmi les processus. Dans le modèle
asynchrone (par opposition au pseudo-synchrone), une stratégie distribuée F : (Σ · S V )∗ → 2Σ
p
p
V ∗
est une stratégie telle qu’il existe un tuple de stratégies
S locales (f )p∈Procp avec f : (Σ·S ) →
p
V
∗
Σ
2 , et telles que, pour tout α ∈ (Σ · S ) , F (α) = p∈Proc|f p (α) défini f (α).
′
Une stratégie distribuée F : (Σ′ · S V )∗ → 2Σ dans le modèle pseudo-synchrone est une
p
stratégie telle qu’il existe un tuple de stratégiesSlocales (f p )p∈ProcS avec f p : (Σ′ ·S V )∗ → 2Σ , et
telles que, pour tout α ∈ (Σ′ · S V )∗ , F (α) = ∅6=P ⊆{p∈Proc|f p (α) défini} {(ap )p∈P | ap ∈ f p (α)}.
La stratégie distribuée F propose donc l’ensemble des tuples d’actions proposées par ses
stratégies. Comme ce n’est pas le système, mais l’ordonnanceur qui va décider quel ensemble
de processus sera autorisé à jouer, on impose à la stratégie F de proposer des tuples d’actions
concernant tous les sous-ensembles possibles de processus.
Dans les deux cas, la condition (2.3) implique que, pour tout α = A1 s1 · · · Ai si ∈ (Σ′ ·S V )∗ ,
f penv (α) = en(si ) ∩ ΣN C (avec si = s0 si α = ε).
On dit que la stratégie distribuée F est déterministe si f p : (Σ′ × S V )∗ → Σp pour tout
p ∈ ProcS .
On dit qu’elle est totale si f p est une fonction totale pour tout p ∈ ProcS .
Encore une fois, on se restreint aux programmes à mémoire locale, c’est-à-dire que le
contrôleur de chaque processus ne dépend que de la valeur de ses variables en lecture. Ici,
plus précisément, le contrôleur ne dépend que de la valeur des variables qu’il a effectivement
eu l’occasion de lire au cours de l’exécution. Pour cela, on définit pour chaque processus
−1
p ∈ ProcS , une fonction viewpV P : (Σ′ · S V )∗ → (S E (p) )∗ la fonction qui associe à un mot
représentant une exécution la séquence de valeurs des variables lue par p. Formellement, pour
40
Chapitre 2. Formalismes
α = a1 s1 · · · ai si , viewpV P (α) = (si1 · · · sik )E
−1 (p)
où la séquence i1 < · · · < ik vérifie :
i1 = min{0 ≤ l < i | al+1 ∈ Σpr ∪ Σpm }
ik = max{0 ≤ l < i | al+1 ∈ Σpr ∪ Σpm }
ij = min{l > ij−1 | al+1 ∈ Σpr ∪ Σpm }
Définition 2.44 (Stratégie à mémoire locale sur les variables). Une stratégie pour le processus p ∈ ProcS f p : (Σ′ × S V )∗ → Σp est à mémoire locale sur les variables si, pour tout
α, α′ ∈ (Σ′ × S V )∗ , si
viewpV P (α) = viewpV P (α′ )
alors
f p (α) = f p (α′ )
Une stratégie distribuée F = (f p )p∈Proc est dite à mémoire locale sur les variables si f p est à
mémoire locale sur les variables pour tout p ∈ ProcS .
Exécutions équitables Dans le cas d’exécutions asynchrones, une exécution selon la stratégie peut ne comporter que des actions de l’environnement. On peut vouloir considérer de
telles exécutions comme des cas dégénérés, et ne pas les inclure dans l’ensemble des exécutions devant satisfaire la spécification. Dans ce cas, le problème de contrôle est de déterminer
l’existence d’une stratégie dont toutes les exécutions équitables satisfont la spécification. On
peut définir plusieurs notions d’exécution équitable. En particulier,
Définition 2.45. Une exécution F -compatible α = s0 A1 s1 A2 s2 · · · ∈ S V · (Σ′ · S V )∞ est
– impartiale si le système contrôlable a pu jouer une infinité de fois, i.e., si α est telle
que |π{A∈Σ′ |A∩ΣC 6=∅} (α)| = ω,
– faiblement équitable si le système contrôlable a pu jouer une infinité de fois si son
programme était défini continûment, i.e., s’il existe i0 tel que, pour tout i ≥ i0 il existe
p ∈ ProcS tel que f p (A1 s1 · · · Ai si ) est défini,
– fortement équitable si le système contrôlable a pu jouer une infinité de fois si son
programme était défini infiniment souvent, i.e., si pour tout i il existe j ≥ i pour lequel
il existe un processus p ∈ Proc tel que f p (A1 s1 · · · Aj sj ) est défini.
On note respectivement RunsiF (A), RunseF (A) et RunsE
F (A) l’ensembles des exécutions
impartiales, faiblement équitables, fortement équitables, respectant la stratégie F .
Remarque 2.46. Les notions d’équité définies ci-dessus découlent d’une vision centralisée du
système : ce qui nous intéresse, c’est si l’ensemble des processus vu comme une entité a pu
jouer de façon équitable. On pourrait également définir des équités locales, tendant à s’assurer
que chaque processus a pu jouer de façon équitable.
Remarque 2.47. La notion d’exécution impartiale n’est pertinente que lorsqu’on se restreint
à des stratégies totales. Sinon le problème a une solution triviale avec une stratégie qui n’est
jamais définie. Par la suite, lorsque l’on considérera des exécutions impartiales, il sera implicitement admis que l’on se restreint à des stratégies totales.
2. Le problème de synthèse et de contrôle distribués
41
Définition 2.48 (Le problème de synthèse (respectivement de contrôle) général (respectivement impartial, faiblement équitable, fortement équitable) de systèmes distribués asynchrones
(respectivement pseudo-synchrones), à communication par variables partagées, pour des architectures à lecture et écritures alternées (respectivement simultanées)). Étant donnés
– une architecture A = (Σ, V, E, (S v )v∈V , s0 , (δa )a∈Σ ) à synthétiser (respectivement à
contrôler), à lecture et écriture strictement alternées (respectivement simultanées),
– un ensemble Proc donnant une
S partition des Σvariables de V etp donc des actions, et
′
′
Σ = Σ (respectivement Σ = P ∈2Proc \∅ {A ∈ 2 | ∀p ∈ P, |A ∩ Σ | = 1}),
– une spécification totale sur les valeurs de variables,
existe-t-il une stratégie distribuée et non-bloquante F déterministe à mémoire locale sur les
i
e
E
variables telle que Runsmax
F (A) (respectivement RunsF (A), RunsF (A), RunsF (A))⊆ Spec ?
Le cas asynchrone (par opposition au modèle pseudo-synchrone) avec variables partagées
comme seul moyen de communication n’a été considéré que pour des systèmes centralisés, i.e.,
dans lequel |ProcS | = 1.
Théorème 2.49 ([PR89b, WTD91]). Le problème de synthèse impartial de systèmes centralisés asynchrones à communication par variables partagées, pour des architectures à lecture et
écriture strictement alternées, est décidable et 2EXPTIME-complet pour les spécifications de
LTL(V ).
On rappelle que dans une architecture à synthétiser, toutes les actions sont toujours possibles, donc un processus n’est jamais bloqué. Une stratégie non-bloquante sera donc toujours
totale.
Le problème de synthèse équitable a été explicitement posé et résolu dans [AM94], puis
dans [Var95] qui a présenté une méthode de résolution par automates :
Théorème 2.50 ([AM94, Var95]). Le problème de synthèse impartial (respectivement faiblement équitable, fortement équitable) de systèmes centralisés asynchrones à communication
par variables partagées, pour des architectures à lecture et écriture simultanées, est décidable
pour des spécifications ω-régulières.
De plus, lorsque la spécification est donnée par un automate de Büchi, [Var95] a montré
que le problème est 2EXPTIME-complet.
En fait, ce mécanisme de communication se révèle très faible dans un système asynchrone :
en effet, lorsqu’un processus écrit sur une variable à destination d’un autre processus, il n’a
aucune garantie que l’information sera effectivement transmise. De même, quand un processus
lit une variable d’un autre processus, il n’a aucun moyen de savoir s’il a perdu de l’information,
et combien. Cette intuition est formalisée par le résultat suivant :
Théorème 2.51 ([FS06]). Le problème de synthèse général de systèmes distribués pseudosynchrones à communication par variables partagées, pour des architectures à lecture et écriture simultanées (et des stratégies totales) est décidable pour les spécifications du µ-calcul si
et seulement si |ProcS | = 1.
2.3.2
Communication par synchronisation d’actions
Dans cette modélisation des communications, les processus évoluent de façon totalement
asynchrone sur leurs variables, et, de temps en temps, décident de faire une action commune.
42
Chapitre 2. Formalismes
L’information se transmet donc à travers cette synchronisation des processus sur les actions.
Les variables ne servent donc plus à communiquer, mais uniquement aux calculs locaux des
processus. On peut donc toutes les regrouper en une seule variable privée au processus, et
assimiler l’ensemble des processus à l’ensemble des variables : Proc = V .
Caractéristiques des architectures Une action a ∈ Σ peut donc lire les états de l’ensemble de processus E −1 (a) et modifier ceux de E(a). On se place ici dans le cadre restreint
dans lequel les actions ne dépendent que de l’état des processus qu’elles modifient, i.e., pour
tout a ∈ Σ, E(a) = E −1 (a). On note Σp = {a ∈ Σ | p ∈ E(a)} l’ensemble des actions du
processus p ∈ Proc. Par ailleurs, on fait abstraction des processus incontrôlables interagissant avec le système, et on considère que les actions incontrôlables sont locales : pour tout
a ∈ Σp ∩ ΣN C , E(a) = E −1 (a) = {p}.
Exemple 2.52. La signature représentée sur la figure 2.7 est constituée de l’ensemble d’actions Σ = {a, b, c, d} et de l’ensemble de registres (assimilés donc aux processus) V = Proc =
{p1 , p2 , p3 , p4 }. L’action a est une action partagée par p1 , p2 et p3 , c’est-à-dire que chaque fois
qu’elle est exécutée, elle modifie les états de contrôle de ces trois processus, en fonction de leur
état de départ. L’action b est une action locale au processus p2 , l’action c est partagée entre
p3 et p4 et l’action d est locale au processus p4 . On peut l’enrichir en l’architecture distribuée
très simple suivante : S p1 = {a1 }, S p2 = {a2 , b2 }, S p3 = {a3 , c3 }, S p4 = {c4 , d4 } et
δa (a1 , a2 , a3 ) = (a1 , b2 , c3 )
δb (b2 ) = a2
δc (c3 , c4 ) = (a3 , d4 )
δd (d4 ) = (c4 )
Une autre représentation classique de ce type de systèmes est le produit d’automates synchronisés. Les valeurs S p pour p ∈ Proc donnent l’ensemble des états de l’automate de p, et
les actions partagées par plusieurs processus sont les transitions étiquetées par la même lettre
dans plusieurs automates, et qui sont donc effectuées en même temps : dans notre exemple,
cela correspond à des automates à un ou deux états, et la transition a n’est possible que si
les trois processus concernés sont dans l’état ai , i = 1, 2, 3, et elle change l’état de p2 en b2
et l’état de p3 en c3 . Dans l’état b2 , la seule action possible pour le processus b2 est l’action
locale b.
On dit qu’une architecture est bipartite si le domaine de chaque processus p est partitionné
en états contrôlables et états incontrôlables : pour tout p ∈ Proc, S p = SCp ⊎ SUp C . Les
actions incontrôlables ne sont activables qu’à partir d’un état incontrôlable, et les actions
contrôlables uniquement à partir des états contrôlables. De plus, chaque processus alterne
entre ses états contrôlables et ses états incontrôlables. Formellement, pour tout a ∈ Σ, on
−1
définit δa : S E (a) → S E(a) , fonction partielle, qui vérifie :
Pour tout a ∈ ΣN C tel que E(a) = E −1 (a) = {p}
δa : SUp C → SCp
Pour tout a ∈ ΣC
E −1 (a)
δa : SC
E(a)
→ SU C .
43
2. Le problème de synthèse et de contrôle distribués
a
p1
d
p2
p3
b
p4
c
Fig. 2.7 – Un exemple de signature dans le cas asynchrone avec communication par synchronisation d’actions
S
Exécutions On se place ici dans un modèle dans lequel Σ′ = a∈Σ {a} et on va donc
assimiler Σ′ et Σ. Les exécutions sont alors des mots de S Proc · (Σ · S Proc )∞ , et correspondent
aux exécutions d’un automate asynchrone de [Zie87].
Stratégies On peut choisir de distribuer les contrôleurs de plusieurs façons différentes :
parmi les processus (variables), dans ce cas, on associe un contrôleur à chaque processus, qui
décide des actions qu’il autorise à chaque instant, ou parmi les actions, et alors la décision
d’autoriser une action ou pas est prise au niveau de l’action, en fonction des états de tous les
processus concernés.
Un programme du système F : (Σ · S Proc )∗ → 2Σ est distribué parmi les processus s’il
p
existe un ensemble de stratégies (f p )p∈Proc , f p : (Σ · S Proc )∗ → 2Σ , pour p ∈ Proc, telles
que pour tout α ∈ (Σ · S Proc )∗ , F (α) = {a ∈ Σ | a ∈ f p (α) pour tout p ∈ E −1 (a) = E(a)}.
La stratégie distribuée ne propose une action a que si tous les processus qui y participent la
proposent. On distingue les stratégies distribuées à mémoire locale des stratégies à mémoire
causale.
Pour p ∈ Proc, on définit la vue locale du processus p, vuelp : (Σ · S Proc )∗ → (Σp · S p )∗
par : pour tout α = a1 s1 · · · ai si ∈ (Σ · S Proc )∗ , vuelp (α) = ai1 spi1 · · · aik spik avec i1 < · · · < ik
et {i1 , · · · , ik } = {1 ≤ j ≤ i | aj ∈ Σp }.
Définition 2.53 (Stratégie distribuée parmi les processus, à mémoire locale). Pour tout p ∈
p
Proc, la stratégie f p : (Σ · S Proc )∗ → 2Σ est à mémoire locale si, pour tous α, α′ ∈ (Σ · S Proc )∗
tels que
vuelp (α) = vuelp (α′ ),
on a
f p (α) = f p (α′ ).
On dit qu’une stratégie distribuée parmi les processus F = (f p )p∈Proc est à mémoire locale si,
pour tout p ∈ Proc, f p est à mémoire locale.
Une stratégie à mémoire locale observe donc uniquement la séquence d’actions et d’états
locaux correspondant aux instants où il a effectivement joué. En particulier, le contrôleur ne
44
Chapitre 2. Formalismes
peut savoir si les autres processus ont effectué des actions concurrentes entre deux de ses
propres actions. Pour reprendre le parallèle avec les automates synchronisés, la vue locale du
processus p correspond à l’exécution sur son propre automate.
Les contrôleurs peuvent avoir un autre type de mémoire, plus abstrait : une mémoire
causale. De tels contrôleurs dépendent de toutes les actions ayant eu lieu dans leur passé
causal, i.e., toutes les actions apparaissant dans leur passé dans chaque linéarisation de la
trace correspondant à l’exécution en cours. On suppose ainsi qu’en se synchronisant sur les
actions, les contrôleurs se transmettent les uns aux autres toute l’information qu’ils possèdent.
Formellement, on définit la vue causale du processus p par vuecp : (Σ · S Proc )∗ → M(Σ, D)
tel que pour α tel que πΣ (α) = a1 · · · an ∈ Σ∗ , vuecp (α) est la plus petite trace préfixe de
[πΣ (α)] = ({1, · · · n}, ≤, λ), t′ = (X ′ , ≤, λ) vérifiant, pour tout 1 ≤ i ≤ n, si ai ∈ Σp , i ∈ X ′ .
Remarque 2.54. Formellement, la vue causale d’un processus ne tient pas compte de la séquence d’états visités. On remarque cependant, que A étant déterministe, si le mot α ∈ Σ∗
est bien dans L(A), il est possible de reconstruire, en procédant par récurrence, la séquence
d’états locaux visités au cours de l’exécution, i.e., si on note vuecp (α) = (X, ≤, λ), il est possible d’étiqueter chaque événement e ∈ X par une valeur supplémentaire, σ(e) = s ∈ S E(λ(e)) ,
E −1 (λ(e))
vérifiant s = δλ(e) ((σ(e′ ))e′ ∈Pred(e) ), où Pred(e) est l’ensemble des événements e′ ∈ X tels que
e′ ⋖ e. Cette étiquette donne la valeur des états locaux qui ont été modifiés par l’action λ(e).
De plus, comme par définition, vuecp n’a qu’un seul événement maximal, on peut reconstruire
l’état global atteint après avoir lu vuecp (α).
Définition 2.55 (Stratégie distribuée parmi les processus, à mémoire causale). On dit que
p
la stratégie f p : (Σ · S Proc )∗ → 2Σ du processus p ∈ Proc est à mémoire causale si, pour tous
α = (a1 s1 · · · ai si ), α′ = (a′1 s′1 · · · a′i s′i ) ∈ (Σ · S Proc )∗ tels que
vuecp (α) = vuecp (α′ ),
on a
f p (α) = f p (α′ ).
Une stratégie distribuée parmi les processus F = (f p )p∈Proc est à mémoire causale si pour
tout p ∈ Proc, f p est à mémoire causale.
Pour que la stratégie distribuée vérifie bien les conditions (2.2) et (2.3), les stratégies
locales aux processus doivent vérifier les conditions exprimées ci-après. On appelle, pour tout
p ∈ Proc, tout s ∈ S p , enp (s) = {a ∈ Σp | il existe s ∈ S Proc , sp = s et a ∈ en(s)} l’ensemble
des actions localement activables par le processus p. Alors, pour tout p ∈ Proc, pour tout
α = (a1 s1 · · · ai si ) ∈ (Σ′ · S V )∞ , avec si = s0 si α = ε,
f p(α) ⊆ enp (spi )
p
f (α) ∩ ΣN C =
enp (spi )
(2.10)
∩ ΣN C
(2.11)
Remarque 2.56. Par la remarque 2.54, si α = a1 s1 · · · ai si , α′ = a′1 s′1 · · · a′i s′i ∈ Runs(A) sont
tels que vuecp (α) = vuecp (α′ ), alors spi = s′p
i .
On décrit maintenant formellement comment distribuer un contrôleur parmi les actions :
une stratégie F : (Σ · S Proc )∗ → 2Σ est distribuée parmi les actions si elle est formée par un
2. Le problème de synthèse et de contrôle distribués
45
tuple F = (f a )a∈Σ tel que pour tout a ∈ Σ, f a : (Σ · S Proc )∗ → {⊤, ⊥}. On définit, pour tout
α ∈ (Σ · S Proc )∗ , F (α) = {a ∈ Σ | f a (α) = ⊤}.
On cherche également des stratégies à mémoire causale. On définit la vue d’une action
a ∈ Σ, vueca : (Σ · S Proc )∗ → M(Σ, D), de la façon suivante : pour tout α = a1 s1 · · · an sn ∈ (Σ ·
S Proc )∗ , vueca (α) est la plus petite trace préfixe t′ = (X ′ , ≤, λ) de [πΣ (α)] = ({1, · · · , n}, ≤, λ)
telle que pour tout 1 ≤ i ≤ n, pour tout p ∈ E(a), si ai ∈ Σp , i ∈ X ′ .
Remarque 2.57. De la même manière que pour la vue causale des processus, pour α ∈
Runs(A), à partir d’une trace vueca (α), on peut reconstituer les états locaux parcourus au
cours de l’exécution de A.
Définition 2.58 (Stratégie distribuée parmi les actions, à mémoire causale). Une stratégie
f a : (Σ · S Proc )∗ → {⊤, ⊥} pour l’action a ∈ Σ est à mémoire causale si, pour tout α =
(a1 s1 · · · ai si ), α′ = (a′1 s′1 · · · a′i s′i ) ∈ (Σ · S Proc )i tels que
vueca (α) = vueca (α′ ),
on a
f a (α) = f a (α′ ).
Une stratégie distribuée parmi les actions F = (f a )a∈Σ est à mémoire causale si pour tout
a ∈ Σ, f a est à mémoire causale.
Pour que la stratégie distribuée vérifie bien les conditions (2.2) et (2.3), les stratégies
locales aux actions doivent vérifier, pour tout a ∈ Σ, pour tout α = (a1 s1 · · · ai si ) ∈ Runs(A),
avec si = s0 si α = ε,
f a (α) = ⊤ implique que a ∈ en(si )
a
si a ∈ ΣN C f (α) = ⊤ si et seulement si a ∈ en(si )
(2.12)
(2.13)
Exemple 2.59. On va illustrer les différences entre les trois vues possibles que l’on vient de
décrire en reprenant l’architecture décrite dans l’exemple 2.52. Dans cet exemple, la relation
de dépendance est donnée par D= {(a, b), (b, a), (a, c), (c, a), (c, d), (d, c)}. Considérons l’exécution πΣ (α) = abcadcadb. La trace correspondante est représentée sur la figure 2.8(a). La
vue locale du processus p1 est alors vuelp1 (α) = aaa, tandis que sa vue causale est représentée
sur la figure 2.8(b). La vue causale de l’action a (voir figure 2.8(c)) contient en plus la dernière
action b jouée. En effet, le processus p2 participe à l’action a, donc le contrôleur de l’action a
connaı̂t également la dernière action jouée sur p2 , et tout son passé.
Spécifications Afin de simplifier la présentation, on supposera par la suite que les systèmes sont non-bloquants. On va également se restreindre à des stratégies non-bloquantes,
donc les exécutions compatibles avec une stratégie, et maximales, seront toutes infinies. Les
spécifications seront données par un automate de Büchi Aϕ sur les mots de Σω .
Le problème de synthèse de contrôleurs Soit A = (Σ, Proc, (S p )p∈Proc , s0 , (δa )a∈Σ ) une
architecture distribuée. On dit que A est à synthétiser si, pour tout p ∈ Proc, |S p | = 1, et
pour tout s ∈ S, en(s) = Σ. On peut maintenant définir différentes variantes du problème
de synthèse de contrôleurs pour des systèmes distribués en sémantique asynchrone, avec des
communications par synchronisation d’actions :
46
Chapitre 2. Formalismes
b
a
b
a
c
b
a
a
a
c
c
d
d
a
c
d
(a) La trace
(b) La vue causale du processus p1
b
a
b
a
c
a
c
d
(c) La vue causale de l’action a
Fig. 2.8 – La trace [πΣ (α)] et deux vues causales
Définition 2.60 (Le problème de contrôle (respectivement de synthèse) de systèmes distribués asynchrones avec stratégies à mémoire locale distribuées parmi les processus (respectivement à mémoire causale distribuées parmi les processus, à mémoire causale distribuées parmi
les actions). Étant donnés
– une architecture A = (Σ, V, E, (S v )v∈V , s0 , (δa )a∈Σ ) à contrôler (respectivement, à synthétiser),
– un langage ω-régulier Lϕ ⊆ Σω ,
existe-t-il une stratégie F non bloquante, à mémoire locale distribuée parmi les processus (respectivement à mémoire causale distribuée parmi les processus, à mémoire causale distribuée
parmi les actions) telle que Runsmax
F (A) ⊆ Lϕ ?
2.3.3
Résultats de la littérature
On commence par remarquer que, dans les cas que nous avons décrits de stratégies à
mémoire locale ou causale, RunsF (A) est toujours clos par équivalence de trace. Par contre,
le langage Lϕ n’a a priori pas de raison de l’être. Il se peut donc que Runsmax
F (A) 6⊆ Lϕ
uniquement parce que le langage de spécification discrimine deux linéarisations de la même
trace.
Les stratégies à mémoire locale distribuées parmi les processus Soit f p : (Σ ·
p
S Proc )∗ → (2Σ ) une stratégie à mémoire locale pour le processus p ∈ Proc. Tout d’abord,
on définit une notion de mémoire locale restreinte, utilisée par [MT02b]. Avec ce type de
mémoire, les contrôleurs ne tiennent pas compte de la séquence d’états visités au cours de
l’exécution, mais uniquement de l’état courant du processus. En effet, les spécifications ne
portant que sur les séquences d’actions exécutées, le contrôleur ne tient compte que de ce qui
a été joué localement, ainsi que de l’état courant du processus qu’il contrôle (ceci afin d’être
à même de proposer des actions activables). On remarque que cette définition donne une
47
2. Le problème de synthèse et de contrôle distribués
mémoire plus restreinte que la définition 2.53, car, bien que l’architecture soit déterministe,
la séquence des états locaux visités dépend également de la séquence des actions jouées par
les autres processus, que l’on ne peut pas reconstruire avec une simple mémoire locale.
p
Définition 2.61 (Stratégies à mémoire locale restreinte). On dit que f p : (Σ · S Proc ) → 2Σ
est une stratégie à mémoire locale restreinte si, pour tout α = a1 s1 · · · ai si et pour tout
α′ = a′1 s′1 · · · a′i s′i tels que
πΣp (a1 · · · ai ) = πΣp (a′1 · · · a′i )
et
spi = s′p
i
alors
f p (α) = f p (α′ )
On définit maintenant deux restrictions sur les stratégies : la première concerne la mémoire
des stratégies ; on se restreint aux stratégies qui ne dépendent que de l’état local courant du
processus, et du nombre de fois que le processus a effectué une transition. Le contrôleur est
donc complètement ignorant de l’histoire des actions qui a été effectuée.
p
Définition 2.62 (Stratégies à mémoire temporelle). Soit f p : (Σ·S Proc )∗ → 2Σ une stratégie
pour le processus p ∈ Proc. On dit que f p est à mémoire temporelle si, pour toutes séquences
α = a1 s1 · · · ai si , α′ = a′1 s′1 · · · a′i s′i ∈ (Σ · S Proc )∗ telles que
spi = s′p
i
on a
f p (α) = f p (α′ ).
On dit qu’une stratégie distribuée F = (f p )p∈Proc est à mémoire temporelle si pour tout
p ∈ Proc, f p est à mémoire temporelle.
La seconde restriction concerne l’ensemble des actions conseillées par la stratégie à un
instant donné. On demande que l’ensemble des actions proposées par la stratégie après avoir
vu une histoire donnée soit des actions partagées avec les mêmes processus. La stratégie
commence donc par décider avec quels processus elle veut communiquer, avant de proposer
un choix d’actions à effectuer de façon synchronisée avec ces derniers :
p
Définition 2.63 (Stratégies à communication rigide). Soit f p : (Σ · S Proc )∗ → 2Σ une
stratégie du processus p ∈ Proc. On dit que f p est à communication rigide si pour toute
séquence σ ∈ (Σp )∗ , il existe un ensemble X ⊆ Proc tel que pour toute séquence α ∈ (Σ·S Proc )∗
telle que
πΣp (α) = σ
pour tout a ∈ f p (α), on a
X = E(a).
Dans [MT02b], a été définie la restriction du problème de contrôle de systèmes distribués
suivante, ne considérant que des architectures bipartites (définies au début de la section 2.3.2) :
Définition 2.64 (Le problème restreint de contrôle de systèmes distribués asynchrones avec
stratégies à mémoire locale distribuées parmi les processus). Étant donnés
48
Chapitre 2. Formalismes
– une architecture A = (Σ, V, E, (S v )v∈V , s0 , (δa )a∈Σ ) bipartite
– Lϕ , un langage ω-régulier clos par équivalence de traces
existe-t-il une stratégie distribuée F , non-bloquante, à mémoire temporelle et à communication
rigide telle que Runsmax
F (A) ⊆ Lϕ ?
Théorème 2.65 ([MT02b]). Le problème restreint de contrôle de systèmes distribués asynchrones avec stratégies à mémoire locale distribuées parmi les processus est décidable. De plus,
s’il existe une stratégie distribuée non-bloquante gagnante, on peut effectivement synthétiser
une stratégie distribuée gagnante à états finis.
On appelle R1, R2 et R3 les restrictions du problème de contrôle considérées : R1 est la restriction aux langages de spécification clos par équivalence de traces, R2 celle aux programmes
à mémoire temporelle, et R3 celle aux programmes à communication rigide.
Si les restrictions R3 et surtout R1 peuvent sembler naturelles, la restriction R2 est très
forte en ce qu’elle n’autorise presque pas de mémoire aux contrôleurs. Cependant, si l’on
relâche une de ces trois restrictions, le problème devient indécidable :
Théorème 2.66 ([MT02b]). Le problème restreint de contrôle de systèmes distribués asynchrones avec stratégies à mémoire locale distribuées parmi les processus dans lequel on a retiré
une ou plusieurs des restrictions R1 , R2 ou R3 est indécidable.
Les stratégies à mémoire causale En augmentant la mémoire des contrôleurs avec l’ensemble des informations dans son passé causal, on peut s’affranchir de ces restrictions. En
particulier, à partir du moment où l’on se restreint à des spécifications closes par équivalence
de traces, le problème de contrôle de systèmes distribués asynchrones avec stratégies à mémoire causale distribuée parmi les processus devient décidable pour une classe d’architectures
dites communiquant de façon connexe.
On commence définir la notion de processus séparés au cours d’une exécution (définie
dans [MTY05]) : on dit que deux processus sont séparés dans une exécution finie s’ils ne
communiquent pas, même indirectement :
Définition 2.67 (Processus séparés). Soient p, q ∈ Proc, et α ∈ Σ∗ . On dit que p et q sont
séparés dans α si il existe τ = t1 · · · tn , τ ′ = t′1 · · · t′m ∈ Σ∗ tels que
– α ∼ ττ′
– pour tout 1 ≤ i ≤ n, 1 ≤ j ≤ m, E(ti ) ∩ E(t′j ) = ∅, i.e., τ ∼ τ ′ ,
/ Σp
– pour tout 1 ≤ i ≤ n, ti ∈
/ Σq , pour tout 1 ≤ j ≤ m, t′j ∈
Une architecture est k-communiquante si, quand deux processus cessent de communiquer
au cours d’une exécution pendant au moins k transitions, ils perdent la possibilité de communiquer dans toutes les prolongations d’exécutions possibles (voir également [MTY05]).
Définition 2.68 (Architecture k-communiquante). Une architecture A est k-communiquante
si et seulement si, pour tout α ∈ Σ∗ préfixe d’un mot de L(A), pour tout p, q ∈ Proc, s’il
existe α1 ∈ Σ∗ tel que
– αα1 ∈ L(A)
– |πΣp (α1 )| ≥ k et |πΣq (α1 )| = 0
alors p et q sont séparés dans α2 , pour tout α2 ∈ Σ∗ tel que αα1 α2 ∈ L(A).
À partir de ces notions, [MTY05] définissent :
2. Le problème de synthèse et de contrôle distribués
49
Définition 2.69 (Architectures communiquant de façon connexe (CCP)). Une architecture
A = (Σ, V, E, (S v )v∈V , so , (δa )a∈Σ ) est un CCP si et seulement si il existe un entier k telle
qu’elle est k-communiquante.
Proposition 2.70 ([MTY05]). Déterminer si une architecture est un CCP est décidable.
Théorème 2.71 ([MTY05]). Le problème de contrôle de systèmes distribués asynchrones
avec stratégies à mémoire causale distribuées parmi les processus est décidable pour les spécifications w-régulières closes par équivalence de traces et les architectures communiquant de
façon connexe.
Les stratégies à mémoire causale distribuées parmi les actions sont encore plus puissantes.
Le principal résultat de décidabilité pour ce formalisme peut être énoncé comme suit.2 On
définit tout d’abord la notion d’alphabet de dépendance de type co-graphe, formé par produit
série et produit parallèle d’alphabets de dépendance. Le produit série de deux alphabets
de dépendance est l’union des deux alphabets, dans laquelle toutes les actions de l’un sont
dépendantes des actions de l’autre. Dans le produit parallèle par contre, toutes les actions de
l’un sont indépendantes des actions de l’autre. Formellement :
Définition 2.72 (Produit série). Soient (Σ1 , D1 ) et (Σ2 , D2 ) deux alphabets de dépendance.
Alors le produit série de (Σ1 , D1 ) et (Σ2 , D2 ) est l’alphabet de dépendance (Σ1 , D1 )·(Σ2 , D2 ) =
(Σ1 ⊎ Σ2 , D1 ∪ D2 ∪ Σ1 × Σ2 ∪ Σ2 × Σ1 ).
Définition 2.73 (Produit parallèle). Soient (Σ1 , D1 ) et (Σ2 , D2 ) deux alphabets de dépendance. Alors le produit parallèle de (Σ1 , D1 ) et (Σ2 , D2 ) est donné par l’alphabet de dépendance (Σ1 , D1 ) k (Σ2 , D2 ) = (Σ1 ⊎ Σ2 , D1 ∪ D2 )
Définition 2.74 (Alphabet co-graphe). Un alphabet de dépendance est un alphabet co-graphe
s’il appartient à la plus petite classe d’alphabets de dépendance contenant les singletons, et
fermée par produit série et produit parallèle.
Théorème 2.75 ([GLZ04, Ler05]). Le problème de contrôle de systèmes distribués asynchrones avec stratégies à mémoire causale distribuées parmi les actions est décidable pour les
architectures dont l’alphabet de dépendance est un co-graphe et des spécifications ω-régulières
closes par équivalence de traces.
En fait, les stratégies à mémoire causale ont plus de puissance lorsqu’elles sont distribuées
parmi les actions que parmi les processus. Cette différence réside dans la quantité d’information disponible au contrôleur pour prendre une décision. Dans le cas de contrôleurs attachés
aux processus, ce dernier prend la décision de faire une action partagée avec un autre processus sans connaı̂tre l’état de cet autre processus. Par contre, un contrôleur attaché à une
action a la possibilité de connaı̂tre les états courants de tous les processus participant à cette
action avant de l’autoriser ou non. En particulier, [MWZ09] ont exhibé une architecture et
une spécification pour laquelle il existait une stratégie gagnante distribuée parmi les actions,
mais pas de stratégie distribuée parmi les processus.
Par ailleurs on peut réduire le contrôle de systèmes distribués avec stratégies distribuées
parmi les processus à celui avec stratégies distribuées parmi les actions :
2
Originellement le théorème 2.75 a été établi dans un modèle un peu plus général que celui présenté ici.
En particulier, les architectures ne sont pas nécessairement déterministes. De plus les domaines de lecture
et d’écriture des actions peuvent être distincts. Enfin, les stratégies à synthétiser ne sont pas nécessairement
non-bloquantes. On a ici suivi le choix de présentation de [MWZ09] afin d’unifier les résultats.
50
Chapitre 2. Formalismes
Théorème 2.76 ([MWZ09]). Pour toute architecture A et langage ω-régulier clos par équivalence de traces LSpec on peut construire une architecture A et un langage LSpec tels qu’il
existe F , une stratégie distribuée parmi les processus gagnante pour (A, LSpec ) si et seulement
si il existe F une stratégie distribuée parmi les actions gagnante pour (A, LSpec ).
Malheureusement, cette réduction ne conserve pas les alphabets de dépendance, et en particulier ne conserve pas la propriété d’être un co-graphe. Elle ne peut donc servir à transférer
les résultats de décidabilité de [GLZ04] au problème de contrôle avec stratégies distribuées
parmi les processus.
Par contre,
Théorème 2.77 ([MWZ09]). Le problème de contrôle de systèmes distribués asynchrone avec
stratégies à mémoire causale distribuées parmi les actions est décidable pour les architectures
communiquant de façon connexes, pour des spécifications ω-régulières closes par équivalence
de traces.
Chapitre 3
Synthèse de systèmes synchrones
Sommaire
1
2
3
4
5
Le modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Architectures à information incomparable . . . . . . . . . . . . . .
Architectures uniformément bien connectées . . . . . . . . . . . . .
3.1
Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2
Décider la connexion uniforme . . . . . . . . . . . . . . . . . . . . .
3.3
Le problème de SSD synchrone pour les architectures UWC . . . . .
3.4
Architectures UWC et spécifications robustes . . . . . . . . . . . . .
Architectures bien connectées . . . . . . . . . . . . . . . . . . . . . .
4.1
Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2
Architecture à information linéairement préordonnée indécidable . .
Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
64
74
74
75
83
88
89
90
91
97
Dans ce chapitre, on traite du problème de synthèse de système distribué synchrone. Plus
particulièrement, on cherche à étudier sous quelles restrictions, les plus naturelles possibles, le
problème devient décidable. En fait, l’indécidabilité est très vite atteinte lorque l’on s’autorise
des spécifications totales. Il est vrai que, dans les cas positifs où l’on obtient de la décidabilité,
comme dans le cas des architectures pipeline, considérer des spécifications totales renforce
le résultat. Cependant, une telle hypothèse affaiblit les résultats d’indécidabilité. En effet,
les spécifications totales permettent de supprimer des liens de communication existant dans
l’architecture (en imposant qu’une variable de communication entre deux processus prenne
toujours la même valeur par exemple) et donc de se réduire facilement à l’architecture indécidable de Pnueli-Rosner (voir figure 2.4 page 32).
Par ailleurs, les spécifications externes sont très naturelles d’un point de vue pratique :
lorsque l’on définit une spécification, on s’intéresse surtout au comportement visible (de type
entrée-sortie) du système. La façon dont les processus communiquent de façon interne afin de
satisfaire cette spécification devrait être laissée totalement libre.
Pour toutes ces raisons, on prétend qu’établir un critère nécessaire et suffisant de décidabilité pour le problème de contrôle de systèmes distribués synchrones est plus intéressant et
plus utile (bien que plus difficile) lorsqu’on se restreint aux spécifications externes, par rapport
aux spécifications totales. En effet, on sait déjà qu’avec des spécifications externes, l’architecture représentée sur la figure 2.6 page 36 est décidable, et on va montrer dans ce chapitre
que l’architecture dessinée figure 2.3 page 29 devient décidable, alors que ce n’est pas une
51
52
Chapitre 3. Synthèse de systèmes synchrones
architecture ordonnée au sens de [FS05] et donc qu’elle est indécidable pour des spécifications
totales.
Pour exposer les résultats et les démonstrations de ce chapitre, il sera plus agréable d’utiliser un formalisme légèrement différent de celui utilisé dans le chapitre 2, en faisant abstraction
de la notion d’action, pour se concentrer sur celle de variable. On commence donc par présenter les notations que nous allons utiliser, ainsi que par montrer formellement que le problème
considéré est bien équivalent au problème de synthèse de système distribué synchrone présenté
dans la section 2.2. Ainsi, on situe clairement le modèle choisi par rapport aux autres résultats
de la littérature. On définit ensuite trois grandes classes d’architectures : les architectures à
information incomparable, dont on montre qu’elles sont toutes indécidables pour les spécifications externes, sont présentées section 2. Puis on introduit les architectures uniformément
bien connectées pour lesquelles on montre que si elles ne sont pas à information incomparable,
elles sont décidables pour des spécifications externes de CTL∗ . Formulé autrement, on montre
donc que si le fait d’être à information incomparable est une condition suffisante pour obtenir l’indécidabilité du problème de synthèse de système distribué avec spécifications externes,
dès lors que l’on se restreint aux architectures uniformément bien connectées, cette condition
devient également nécessaire. La complexité, et même la décidabilité d’une telle propriété sur
une architecture donnée n’étant pas triviale, on consacre une partie de ce chapitre à l’analyse
de cette complexité. Enfin on présente la classe plus étendue des architectures bien connectées pour lesquelles on montre qu’être à information incomparable n’est plus une condition
suffisante d’indécidabilité (voir figure 3.12 pour un récapitulatif).
1
Le modèle
On s’intéresse au problème de synthèse de système distribué synchrone avec spécifications
externes tel qu’exposé dans la définition 2.29 page 31. Comme annoncé, on étend par ailleurs
les délais des processus à des valeurs arbitraires : pour tout p ∈ ProcS , dp ∈ N. De plus, quand
l’architecture considérée est à synthétiser, les registres vp de chaque processus p ∈ Proc et
l’alphabet précis d’actions Σ sont inutiles. On va donc utiliser par la suite un formalisme dans
lequel on fait abstraction des registres et des actions, dans lequel la notion de délai variable
s’exprime facilement, et qui sera également plus pratique pour les démonstrations.
On montre que, dans le cas d’architectures 0-délai et 1-délai, le problème qu’on décrit est
équivalent au modèle précédent.
Remarque 3.1. Le modèle général présenté au chapitre 2 peut être légérement modifié afin de
capturer la notion de délai arbitraire : lorsqu’un processus a un délai supérieur à 1, les actions
qu’il joue s’appliquent sur des états locaux plus anciens que l’état courant, ou l’état précédent.
Il faudrait donc définir une transition sur des séquences d’états globaux suffisamment longues
pour que la valeur sur laquelle l’action va s’appliquer apparaisse dans la séquence. Pour
modéliser un délai 2 par exemple, il faudrait considérer un système de transition dont les
états globaux sont des mots de (S V )2 .
Architectures.
Les architectures que nous allons considérer sont maintenant de la forme
A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc )
dans lesquelles Proc est l’ensemble des processus, V est l’ensemble des variables, E ⊆ (Proc ×
V ) ∪ (V × Proc) indique quelles variables sont lues ou modifiées par quels processus, S v est le
53
1. Le modèle
domaine de la variable v ∈ V , s0 ∈ S V et dp ∈ N le délai associé au processus p ∈ Proc. On ne
représente plus explicitement non plus le processus environnement, ce qui a pour conséquence
que certaines variables n’ont pas de prédécesseur ou de successeur dans le graphe formé par
(V ∪ Proc, E).
Dans ce modèle, les notions de variables d’entrée et de sortie du système correspondent
respectivement à
VI = {v ∈ V | E −1 (v) = ∅}
et
VO = {v ∈ V | E(v) = ∅},
et le fait qu’une variable n’est modifiée que par le processus à qui elle appartient s’écrit :
pour tout v ∈ V , |E −1 (v)| ≤ 1. On se restreint aux architectures acycliques, i.e., celles dont
le graphe formé par les sommets V ∪ Proc et les arcs E est également acyclique. On remarque
que la notion de graphe d’une architecture coı̈ncide dans les deux définitions : celle présentée
au chapitre précédent et celle que nous allons utiliser ici (voir la figure 3.1 pour un exemple
de signature d’une architecture acyclique, et sa traduction dans le modèle utilisé dans ce
chapitre). Par ailleurs, dans les figures de ce chapitre, on ne représente plus sur les graphes
les variables d’entrée et de sortie du système comme ayant des arcs entrants et sortants : avec
la définition de VI et VO que l’on prend, les variables d’entrée et de sortie sont simplement
celles n’ayant respectivement aucun prédécesseur ou aucun successeur.
Exécutions. Une exécution de A est un mot σ = s0 s1 · · · ∈ (S V )ω commençant par l’état
initial de A. C’est donc simplement une exécution de T SA dans laquelle on ne tient pas compte
de la séquence d’actions réellement effectuée. Comme de plus, dans le cas de la synthèse, toutes
les transitions locales sont autorisées, tous les mots de (S V )ω sont virtuellement des exécutions
possibles de T SA .
Arbres d’exécutions Un arbre d’exécutions de A est un arbre complet t : (S VI )∗ → S V
vérifiant t(ε) = s0 et, pour tout ρ ∈ (S VI )∗ , tout r ∈ S VI , t(ρ · r)VI = r VI . Pour U ⊆ V ,
la projection tU d’un arbre d’exécutions t sur U est définie par tU (ρ) = t(ρ)U , pour tout
ρ ∈ (S VI )∗ .
Programmes, stratégies On rappelle qu’une stratégie distribuée pour le problème donné
par la définition 2.29 page 31 est un tuple F = (f p )p∈Proc tel que f p : (Σ′ · S V )∗ → Σp est à
mémoire locale, pour tout p ∈ ProcS , et tel que f penv : (Σ′ · S V )∗ → 2ΣNC vérifie, pour tout
α ∈ (Σ′ · S V )∗ , f penv (α) = ΣN C .
Une stratégie distribuée pour A est maintenant un tuple F = (f p )p∈Proc tel que f p :
−1 (p) +
E
(S
) → S E(p) . Au lieu de conseiller une action, la stratégie du processus p calcule
maintenant son effet sur les variables de p et conseille donc un nouvel état local. Le calcul
du nouvel état revient donc à la stratégie distribuée. C’est donc à présent elle qui doit tenir
compte du délai à appliquer à l’action. D’où la définition suivante :
Définition 3.2 (Stratégie d-compatible). Soit A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc une
−1
architecture, p ∈ Proc un processus, et f p : (S E (p) )+ → S E(p) une stratégie pour le processus
p. On dit que f p est compatible avec son délai (ou d-compatible) si, pour tout i > 0, pour
−1
tous σ, σ ′ ∈ (S E (p) )i tels que
σ[i − dp ] = σ ′ [i − dp ],
54
Chapitre 3. Synthèse de systèmes synchrones
b1
a1
r3
b2
p
r1
b3
a2
penv
a3
b4
c1
r2
a4
vp
vq
c2
c3
c4
(a) La signature d’une architecture acyclique à synthétiser A
r1
p
r3
r2
q
r4
(b) Architecture A′ correspondante
Fig. 3.1 – Une architecture acyclique
q
r4
55
1. Le modèle
on a
f p (σ) = f p (σ ′ ).
On dit que F = (f p )p∈Proc est d-compatible si f p est d-compatible, pour tout p ∈ Proc.
Exécutions et arbres d’exécutions selon une stratégie distribuée Une exécution
selon la stratégie distribuée F (ou exécution F -compatible) est un mot σ = s0 s1 · · · ∈ (S V )ω
−1
E(p)
tel que, pour tout i > 0, pour tout p ∈ Proc, si
= f p ((σ[i])E (p) ).
Remarque 3.3. Nos architectures sont acycliques. Donc si on fixe ρ ∈ (S VI )ω , il existe une
unique exécution σ qui soit F -compatible telle que σ VI = ρ. On dit que σ est l’exécution
induite par ρ.
Un arbre d’exécutions selon la stratégie F (ou arbre F -compatible) tF : (S VI )∗ → S V est
un arbre d’exécutions de A tel que pour tout ρ ∈ (S VI )∗ , l’étiquette de la branche ρ est une
exécution F -compatible. Autrement dit, tel que pour tout ρ ∈ (S VI )∗ , pour tout p ∈ Proc,
−1
tF (ρ)E(p) = f p ((t(ρ[1])t(ρ[2]) · · · t(ρ))E (p) ).
Spécifications On rappelle qu’on s’intéresse à des spécifications externes sur les variables.
Une spécification sera donnée par une formule ϕ ∈ L(VI ∪ VO ), avec L = {LTL, CTL, CTL∗ }
dans laquelle les propositions atomiques sont de la forme (v = a) avec v ∈ VI ∪ VO et a ∈ S v .
La validité d’une exécution σ (respectivement d’un arbre d’exécutions t) sur une formule
ϕ ∈ L(VI ∪ VO ) ne dépend que de sa projection σ VI ∪VO (respectivement, tVI ∪VO ) (voir page 29).
On définit à présent la nouvelle version du problème de synthèse de système distribué
synchrone :
Définition 3.4 (Le problème de synthèse de système distribué synchrone). Étant données
une architecture A = (V, Proc, E, (S v )v∈V , s0 , (dp )p∈Proc ) et une spécification externe ϕ ∈
L(VI ∪ VO ), existe-t-il une stratégie distribuée F = (f p )p∈Proc d-compatible telle que pour
toute exécution F -compatible σ, σ |= ϕ (telle que l’arbre F -compatible tF |= ϕ si ϕ est une
formule branchante) ?
Par la suite, on fera référence au problème de synthèse de système distribué avec spécifications externes de la définition 2.29 sous le terme de problème de synthèse général et
au problème de synthèse défini ci-dessus sous le terme de problème de synthèse avec actions
abstraites.
On montre que
Théorème 3.5. Le problème de synthèse général est équivalent au problème de synthèse avec
actions abstraites.
Démonstration.
Tout d’abord on met en relation de façon explicite les deux notions
d’arbres d’exécutions présentées. Soit A un système distribué, entrée du problème de synthèse
général. Soit F un programme du système A, à mémoire locale, et t : (Σ′ )∗ → S V l’arbre
d’exécutions selon F (voir la définition 2.20 page 23). En fait, chaque séquence de valeurs
d’entrée du système peut être engendrée par une séquence d’actions de A. On rappelle que
VI = E(ΣN C ) = E(penv ). Formellement, pour toute séquence de valeurs pour les entrées du
système ρ ∈ (S VI )∗ , il existe une séquence d’actions α ∈ dom(t) telle que (πS V (Val(t)(α)))VI =
ρ. En effet, soit ρ ∈ (S VI )∗ et α ∈ dom(t) tel que ρ = (πS V (Val(t)(α))VI , et r ∈ S VI . Alors, par
−1
l’hypothèse d’environnement maximal, il existe a ∈ ΣN C tel que δa (t(α)E (penv ) ) = r. Comme
56
Chapitre 3. Synthèse de systèmes synchrones
f penv (α) = ΣN C , il existe A ∈ F (α) tel que A(penv ) = a et (t(α), A, t(α · A)) ∈ ⇒. Donc
t(α·A)VI = δA(penv ) (t(α)VO )) = r et donc (πS V (Val(t)(α·A))VI = (t(α·A[1] · · · t(α·A))VI = ρ·r.
On peut alors définir Φt : Σ′∗ → (S VI )∗ fonction surjective telle que, pour tout α ∈ dom(t),
Φt (α) = (πS V (Val(t)(α)))VI .
Comme Φt est croissante, on peut étendre son domaine
de définition
aux mots de (Σ′ )ω
F
F
en posant, pour α ∈ (Σ′ )ω branche de t, Φt (α) = Φt ( α′ ⊑α α′ ) = α′ ⊑α Φt (α′ ). La fonction
Φt ainsi étendue aux mots infinis est aussi surjective. En fait, cette fonction associe à une
séquence d’actions donnée son effet sur les valeur des variables d’entrée du système.
Remarque 3.6. Comme l’architecture A est déterministe, et que F est à mémoire locale, la
définition 2.25 page 28 implique que, si deux séquences d’actions induisent les mêmes séquences
de valeurs sur les variables d’entrée, alors les variables du système vont prendre les mêmes
valeurs. En effet, la décision de chaque stratégie ne dépend que de la valeur des variables
que le processus associé peut lire, et l’effet combiné des actions choisies par les processus est
prévisible. Formellement, pour tout α, α′ ∈ Σ′∗ , tels que
(πS V (Val(t)(α)))VI = (πS V (Val(t)(α′ )))VI
on a
t(α) = t(α′ ).
Cette remarque nous permet donc de justifier le fait de représenter les arbres d’exécutions du système comme branchant sur les valeurs d’entrée et non sur les différentes actions
possibles.
′
On pose t′ : (S VI )∗ → S V arbre complet défini par, pour tout ρ ∈ (S VI )∗ ,
t′ (ρ) = t(α)V
′
(3.1)
′
avec α ∈ Φ−1
t (ρ). Par la remarque 3.6, t est bien défini.
′
Cet arbre t contient moins de branches que l’arbre d’exécutions selon F dont il est issu,
car il réunit en une même branche toutes les séquences d’actions ayant la même exécution
sur A. On montre à présent qu’il est suffisant de vérifier la spécification sur cette version
restreinte des arbres d’exécutions.
Lemme 3.7. Pour tout t : Σ′∗ → S V arbre d’exécutions selon F , pour tout ϕ ∈ CTL∗ (VI ∪VO ),
pour tout α ∈ (Σ′ )ω branche de t, pour tout i ≥ 0,
t, α, i |= ϕ si et seulement si t′ , Φt (α), i |= ϕ.
Démonstration.
Par récurrence sur la structure de ϕ. Le cas (v = a) pour v ∈ VI ∪ VO
′
et a ∈ S v découle de la définition de t′ (Φt (α[i])) = t(α[i])V .
Les cas de formules formées par opérations booléennes sont triviaux.
Si t, α, i |= A ϕ alors pour tout α′ ∈ (Σ′ )ω tel que α[i]α′ est une branche de t, on a
t, α[i] · α′ , i |= ϕ. De plus, pour tout α′ ∈ Σ′ω tel que α[i]α′ est une branche de t, l’hypothèse
de récurrence assure que t′ , Φt (α)[i]Φt (α′ ), i |= ϕ. En effet, Φt (α[i] · α′ ) = Φt (α)[i] · Φt (α′ ).
Alors, par surjectivité de Φt , pour tout ρ′ ∈ (S VI )ω , il est vrai que t′ , Φt (α)[i] · ρ′ , i |= ϕ,
et donc t′ , Φt (α), i |= A ϕ. Réciproquement, si t′ , Φt (α), i |= A ϕ, alors t′ , Φt (α)[i] · ρ′ , i |= ϕ
pour tout ρ′ ∈ (S VI )ω . Donc, pour tout α′ ∈ Σ′ω tel que α[i] · α′ est une branche de t et
57
1. Le modèle
Φt (α[i] · α′ ) = Φt (α)[i] · ρ′ , l’hypothèse de récurrence assure que t, α[i] · α′ , i |= ϕ et donc, pour
tout α′ ∈ Σ′ω tel que α[i] · α′ est une branche de t, on a t, α[i] · α′ |= ϕ. D’où t, α, i |= A ϕ.
Par ailleurs, t, α, i |= ϕ U ψ, si et seulement s’il existe j ≥ i tel que t, α, j |= ψ et t, α, k |= ϕ
pour tout i ≤ k < j. Par hypothèse de récurrence, c’est équivalent à l’existence de j ≥ i tel
que t′ , Φt (α), j |= ψ et tel que t′ , Φt (α), k |= ϕ pour tout i ≤ k < j, ce qui est équivalent à
t′ , Φt (α), i |= ϕ U ψ.
Les autres cas de formules de chemins sont également immédiats.
On montre à présent comment construire une architecture du problème de synthèse avec
actions abstraites à partir d’une architecture du problème de synthèse général. Soient A =
(V = ⊎p∈Proc Vp , Σ, E, (S v )v∈V , s0 , (δa )a∈Σ ) une architecture à synthétiser acyclique, avec
(dp )p∈ProcS les délais associés, et ϕ ∈ CTL∗ (VI ∪ VO ) la spécification. (On ne considère que
la logique CTL∗ car les deux autres en sont des cas particuliers : pour montrer la réduction
avec une formule ψ ∈ LTL(VI ∪ VO ), on se ramène à une formule de CTL∗ en considérant le
problème pour la formule A ψ). On rappelle que dans le cas général, les processus du système
possèdent une variable particulière, vp , représentant leur état de contrôle, et qu’ils peuvent
lire et modifier. Or, dans une architecture à synthétiser, aucun programme n’est pré-établi, et
on suppose que, pour tout p ∈ ProcS , |S vp | = 1. On considère, sans perte de généralité, que
pour tout p ∈ ProcS , S vp = {0}. De plus, on suppose que, pour tout v ∈ V , E −1 (v) 6= ∅, i.e.,
que toute variable du système est lue par un processus. Dans le cas contraire, on supprime
l’ensemble {v ∈ V | E −1 (v) = ∅} de V ′ .
On construit A′ = (V ′ , Proc′ , E ′ , (S ′v )v∈V ′ , s′0 , (d′p )p∈Proc′ ) de la façon suivante :
V ′ = Com
Proc′ = ProcS
S′
v
= S v pour tout v ∈ V ′
s′0 = sV0
′
d′p = dp pour tout p ∈ Proc′
E ′ ⊆ (V ′ × Proc′ ) ∪ (Proc′ × V ′ ) défini par
E ′ = {(v, p) | ∃a ∈ Σp , (v, a) ∈ E} ∪
{(p, v) | v ∈ Vp }.
On rappelle que Com = V \ {vp | p ∈ ProcS }. On a donc supprimé les registres vp des
variables du système car dans ce cas précis, ils n’apportent aucune information. De même,
on fait abstraction du processus environnement, puisque le calcul de sa stratégie est trivial.
Enfin, chaque processus pouvant utiliser des actions ayant toutes les sémantiques possibles,
et les spécifications ne contraignant que les valeurs des variables, donc les effets des actions,
on peut s’abstenir de mentionner explicitement ces dernières : seul compte le résultat sur
les variables de la transition d’une action. Ainsi, comme on l’a déjà mentionné, les stratégies
peuvent décider directement de la valeur qu’elles veulent donner à une variable, peu importe le
nom de l’action utilisée pour obtenir cet effet. On redéfinit donc le graphe de l’architecture qui
lie maintenant les variables et les processus. Comme on s’y attend, les variables modifiables
par un processus sont ses propres variables, et celles qu’il peut lire sont celles pour lesquelles il
existe une action qu’il contrôle qui en dépend. (On pourra à nouveau se référer à la figure 3.1
pour une illustration du passage de l’architecture A à l’architecture A′ ).
58
Chapitre 3. Synthèse de systèmes synchrones
F : A1 s1 · · · Ai−1 si−1
A(p1 )
A(p2 )
..
.
A(pn )
exécution F -compatible :
A1 s1 · · · Ai−1 si−1 (A(p))p∈Proc si
(a) Architecture A
. . . sIn(p) sIn(p)
f ′p : sIn(p)
i−1
1
i
Out(p)
si
. . . sIn(p) sIn(p)
f ′p : sIn(p)
i−1
1
i
δA(p)
′
(b) Architecture A : cas 0-délai
Out(p)
si
δA(p)
′
(c) Architecture A : cas 1-délai
Fig. 3.2 – Les stratégies et les exécutions induites dans A et A′
Il est clair que VI ′ = VI , VO ′ = VO . La spécification ϕ reste donc inchangée au cours de la
réduction. Par ailleurs, pour tout p ∈ Proc′ = ProcS , E ′−1 (p) = In(p) et E ′ (p) = Out(p).
On rappelle que les variables de A diffèrent des variables de A′ simplement par la présence
ou l’absence des états de contrôle des processus du système. Pour passer simplement d’un état
−1
de A′ à un état de A, on utilisera la notation suivante : pour s ∈ S In(p) , on pose s ∈ S E (p)
défini par sv = sv pour tout v ∈ V ′ et svp = 0 pour tout p ∈ ProcS .
Lemme 3.8. S’il existe une stratégie distribuée gagnante pour (A, ϕ) dans le problème de
synthèse général, alors il existe une stratégie distribuée gagnante pour (A′ , ϕ) dans le problème
de synthèse avec actions abstraites.
Soit F = (f p )p∈Proc une stratégie distribuée gagnante
Démonstration du lemme 3.8.
′
′p
pour (A, ϕ). On construit F = (f )p∈Proc′ stratégie distribuée gagnante pour (A′ , ϕ) de la
′−1
façon suivante : soit p ∈ Proc′ , et soit σ = s1 · · · si ∈ (S ′E (p) )+ . Alors σ ∈ (S In(p) )+ . La
stratégie f ′p va imiter le comportement de f p après un préfixe d’exécution ayant engendré
la même séquence d’états : on s’intéresse donc aux exécutions F -compatibles α ∈ RunsF (A)
vérifiant
(πS V (α))In(p) = s1 · · · si−1 .
(3.2)
On remarque que la séquence d’actions choisie n’est pas confrontée à la dernière valeur si .
En effet, dans le modèle initial, la valeur courante d’une variable est déterminée par l’action
effectuée par le processus la modifiant au cours du même instant d’exécution. Le processus
qui nous concerne n’a donc pas accès à cette valeur au moment où il détermine sa stratégie.
Cependant, c’est l’action qui va être choisie par la stratégie du processus p qui va prendre
en compte la valeur de si , puisque la valeur de la variable à modifier sera déterminée par la
59
1. Le modèle
transition de cette action à partir de si (voir la figure 3.2). On pose
(
(δf p (α) (si−dp ))Out(p) avec α ∈ RunsF (A) vérifiant (3.2)
′p
f (σ) =
(0)v∈Out(p)
si aucune exécution F -compatible ne vérifie (3.2)
Le choix d’une séquence d’actions α nous permet d’utiliser l’action f p (α) choisie par la
stratégie du processus p. On rappelle qu’on passe d’un état si−1 à un état si par l’action
A ∈ Σ′ au cours d’une exécution synchrone avec si vérifiant, pour tout p ∈ ProcS ,
E(p)
si
In(p)
v
p
= δA(p) (si−1
, si−dp )
(voir l’égalité (2.6) page 26). Ici, A(p) = f p (α), et on voit que la stratégie f ′p calcule exactement la valeur des variables en écriture en fonction de l’action choisie par f p . Comme l’architecture A est à synthétiser, |S vp | = 1. On rappelle que E −1 (p) = In(p) ∪ {vp }. Donc tous
−1
−1
α, α′ ∈ RunsF (A) vérifiant (3.2) sont tels que πS V (α)E (p) = πS V (α′ )E (p) . Comme de plus,
f p est à mémoire locale, tous α, α′ ∈ RunsF (A) vérifiant (3.2) sont tels que f p (α) = f p (α′ ).
Ceci assure que f ′p est bien défini. Par ailleurs, si on considère σ = s1 · · · si , σ ′ = s′1 · · · s′i ∈
(S In(p) )+ tels que σ[i − dp ] = σ ′ [i − dp ], alors par définition f ′p (σ) = f ′p (σ ′ ) (on rappelle que
dp ∈ {0, 1}). La stratégie F ′ = (f ′p )p∈Proc′ est donc bien définie et d-compatible.
On montre à présent qu’elle est gagnante pour (A′ , ϕ). Soit t : (Σ′ )∗ → S V l’arbre des
′
exécutions F -compatibles. Soit t′ : (S VI )∗ → S V défini par l’équation (3.1). On montre que
′
t′ est bien l’arbre d’exécutions selon F ′ : t′ (ε) = sV0 = s′0 . Soit ρ ∈ (S VI )∗ et r ∈ S VI . Soit
′
′
α · A ∈ dom(t) tel que (πS V (Val(t)(α · A)))VI = ρ · r. Alors t′ (ρ · r) = (t(α · A))V = s ∈ S V .
Donc, par définition, A ∈ F (Val(t)(α)), et (t(α), A, t(α · A)) ∈ ⇒, ce qui implique que, pour
tout p ∈ ProcS = Proc′ ,
(
si dp = 1
(δA(p) (t(α)In(p) ))Out(p)
Out(p)
s
=
Out(p)
(δA(p) (t(α · A)In(p) ))
si dp = 0,
′
avec A(p) = f p (Val(t)(α)). Or, (πS V (Val(t)(α)))V = t′ (ρ[1]) · · · t′ (ρ), donc par définition de
f ′p ,
(
si dp = 1
(δA(p) (t(α)In(p) ))Out(p)
f ′p ((t′ (ρ[1]) · · · t′ (ρ)t′ (ρ · r))In(p) ) =
Out(p)
In(p)
(δA(p) (t(α · A)
))
si dp = 0,
et
t′ (ρ · r)Out(p) = f ′p ((t′ (ρ[1]) · · · t′ (ρ)t′ (ρ · r))In(p) )
Par ailleurs, par construction, t′ (ρ · r)VI = t(α · A)VI = r, et donc t′ est l’arbre des exécutions
selon F ′ .
Comme F est une stratégie distribuée gagnante pour (A, ϕ), t |= ϕ, et par le lemme 3.7,
t′ |= ϕ. Donc, F ′ est une stratégie distribuée gagnante pour (A′ , ϕ).
Réciproquement, à partir d’une architecture du problème de synthèse avec actions abstraites, on peut construire une architecture du problème général de la façon suivante. Soit
A′ = (Proc′ , V ′ , E ′ , (S ′v )v∈V , s′0 , (d′p )p∈Proc ) une architecture pour le problème de synthèse
60
Chapitre 3. Synthèse de systèmes synchrones
avec actions abstraites, dans laquelle, pour
tout p ∈ Proc′ , d′p ∈ {0, 1}. On construit une
U
architecture à synthétiser A = (V = p∈Proc Vp , Σ, E, (S v )v∈V , s0 , (δa )a∈Σ ) avec les délais
(dp )p∈ProcS pour le problème de synthèse général de la façon suivante :
Proc = Proc′ ∪ {penv }
Vp = {v ∈ V ′ | (p, v) ∈ E ′ } ∪ {vp } pour p ∈ Proc′
Vpenv = VI ′
v
S v = S ′ pour v ∈ V ′
S vp = {0} pour p ∈ ProcS
′
sv0 = s′v
0 pour v ∈ V
v
s0p = 0 pour p ∈ Proc′
dp = d′p pour p ∈ Proc′
Σ un alphabet isomorphe à l’ensemble
[
′
S E (p)
SE
′−1 (p)
∪ S VI
′
p∈Proc′
E ⊆ (V × Σ) ∪ (Σ × V ).
Les processus de A sont les mêmes que ceux de A′ à qui on a ajouté le processus environnement. Pour tout processus contrôlable du système, les variables de ce processus sont les
variables que le processus peut modifier dans l’architecture A′ . Comme l’architecture A′ a la
contrainte qu’une variable ne peut être modifiée que par un unique processus, on obtient bien
une partition des variables. De plus, on rajoute pour chaque processus de ProcS son état de
contrôle vp , qui a un domaine de taille 1, puisqu’on construit une architecture à synthétiser.
De même, on se donne un très large alphabet d’actions, puisqu’on veut que toutes les fonctions
de transition soient disponibles dans le système. Soit
δ:Σ→
[
′
S E (p)
SE
′−1 (p)
∪ S VI
′
p∈Proc
une application bijective, qui associe à chaque action sa fonction de transition locale. Les
′−1 (p)
S
SE
′
), et les actions inconactions contrôlables du système sont ΣC = δ−1 ( p∈Proc S E (p)
′
−1
V
I
trôlables sont ΣN C = δ (S ).
On définit à E de la façon suivante : pour tout p ∈ Proc′ , a ∈ δ−1 (S E (p)
contrôlable du système,
′
E −1 (a) = E ′−1 (p) ∪ {vp }
E(a) = Vp
′
pour tout a ∈ δ−1 (S VI ) action incontrôlable du système,
E −1 (a) = VO ′
E(a) = VI ′
Pour tout a ∈ ΣC , on pose à présent
δa = δ(a)
SE
′−1 (p)
) action
61
1. Le modèle
′
et pour tout a ∈ ΣN C , pour tout s ∈ S VO ,
δa (s) = δ(a)
Par ailleurs, on remarque que, comme précédemment, VI = E(ΣN C ) = VI ′ et VO = {v ∈
V | E(v) = ΣN C } = VO ′ , et pour tout p ∈ ProcS = Proc′ , E ′−1 (p) = In(p) et E ′ (p) = Out(p).
−1
On utilisera à nouveau la notation : pour s ∈ S In(p) , on pose s ∈ S E (p) défini par sv = sv
pour tout v ∈ V ′ et svp = 0 pour tout p ∈ ProcS .
Lemme 3.9. S’il existe une stratégie distribuée gagnante pour le problème de synthèse avec
actions abstraites sur (A′ , ϕ) alors il existe une stratégie distribuée gagnante pour le problème
de synthèse général sur (A, ϕ).
Soit F ′ = (f ′p )p∈Proc′ une stratégie distribuée gagnante
Démonstration du lemme 3.9.
′
pour (A , ϕ). Soit p ∈ ProcS et α = A1 s1 · · · Ai−1 si−1 ∈ (Σ′ · S V )∗ , et on va déterminer quelle
action la stratégie f p va proposer. Pour cela, on calcule en fait sa fonction de transition associée
−1
δα : S E (p) → S E(p) à partir des décisions prises par f ′p . On rappelle que les stratégies
dans l’architecture A′ intègrent dans leur calcul l’effet de l’action à jouer en fonction de la
valeur à laquelle elle va s’appliquer. Pour retrouver une stratégie de A, on doit à nouveau
« externaliser » la fonction de transition. Formellement, on pose
δα : S E
−1 (p)
s
→ S E(p)
(
f ′p (πS V (α)In(p) · sIn(p) )
7→
f ′p (πS V (α[|α| − 1])In(p) · sIn(p) · s′ )
si dp = 0
si dp = 1, avec s′ ∈ S In(p) quelconque
Dans le cas où le processus p est à délai 0, après une histoire α = A1 s1 · · · Ai−1 si−1 sur
l’architecture A, les processus choisissent un tuple d’actions (Ai (p))p∈Proc et l’exécution F E(p)
compatible correspondante est α · Ai si avec si
E −1 (p)
= δAi (p) (si
In(p)
). Dans l’architecture A′ , la
Out(p)
la valeur si
. Dans le cas où le délai est
stratégie f ′p associe à l’histoire πS V (α)In(p) · si
1 par contre, la stratégie F des processus de A ne change pas, seule change l’exécution F E(p)
E −1 (p)
compatible associée : à présent elle est α·Ai si avec si
= δA(p) (si−1 ). Sur l’architecture A′ ,
la stratégie f ′p intégrant le calcul de la transition de l’action, est d-compatible : elle ne dépend
In(p)
In(p)
pas de la dernière valeur lue. Elle associe donc à l’histoire (s1 · · · si−2 )In(p) · si−1 · si
=
In(p)
In(p)
πS V (α[|α| − 1])In(p) · si−1 · si
Out(p)
la valeur si
qui, comme dans l’architecture A, ne dépend
In(p)
si
pas de
(voir à nouveau la figure 3.2).
Comme A est une architecture à synthétiser, il existe a ∈ Σp tel que δa = δα , et on pose
f p (α) = a
et
f penv (α) = ΣN C .
Pour tout p ∈ ProcS , si dp = 1 alors par d-compatibilité de f ′p (voir définition 3.2), pour tout
In(p)
In(p)
s′ , s′′ ∈ S In(p) , f ′p (πS V (α[|α| − 1])In(p) · si−1 · s′ ) = f ′p (πS V (α[|α| − 2])In(p) · si−1 · s′′ ), donc
f p est bien définie. De plus, il est clair que f p est à mémoire locale. Donc F = (f p )p∈Proc est
bien une stratégie du système A à mémoire locale.
On montre maintenant que la stratégie F ainsi calculée engendre bien les mêmes exécutions
′
que la stratégie F ′ . Soit t : Σ′∗ → S V l’arbre des exécutions selon F , et t′ : (S VI )∗ → S V
62
Chapitre 3. Synthèse de systèmes synchrones
défini par l’équation (3.1). On montre une fois de plus que t′ est l’arbre des exécutions selon
′
F ′ . Tout d’abord, il est clair que t′ (ε) = t(ε)V = s′0 . Soit maintenant ρ ∈ (S VI )∗ , et r ∈ S VI .
Par définition, t′ (ρ · r)VI = t(α · A)VI avec Φt (α · A) = ρ · r, donc πS V (Val(t)(α · A))VI = ρ · r,
et donc t′ (ρ · r)VI = r. Comme t est un arbre d’exécutions selon F , alors A ∈ F (Val(t)(α)).
Soit p ∈ ProcS = Proc′ . Alors A(p) = f p (Val(t)(α)) et, en appliquant les définitions,
(
−1
δ
(t(α · A)E (p) )Out(p) si dp = 0
Out(p)
t(α · A)
= A(p)
−1
δA(p) (t(α)E (p) )Out(p)
si dp = 1.
(
si dp = 0
f ′p (πS V (Val(t)(α))In(p) · t(α · A)In(p) )
=
f ′p (πS V (Val(t)(α[|α| − 1]))In(p) · t(α)In(p) · t(α · A)In(p) ) si dp = 1.
′
′
Or, πS V (Val(t)(α))V = (t(α[1]) · · · t(α))V = t′ (ρ[1]) · · · t′ (ρ), donc
t(α · A)Out(p) = f ′p ((t′ (ρ[1] · · · t′ (ρ))In(p) · t′ (ρ · r)In(p) )
(3.3)
On remarque que, quel que soit le délai, l’étiquette de t correspond à la valeur calculée par la
stratégie f ′p sur l’étiquette de toute la branche, mais la sémantique différente de f ′p dans les
deux cas entraı̂ne donc des résultats différents. Par ailleurs, on remarque que le paramètre de
la fonction δA(p) se retrouve bien comme dernière valeur de la séquence d’entrée de f ′p dans
le cas 0-délai, et comme avant-dernière valeur de cette séquence dans le cas 1-délai, ce qui
correspond à la définition faite de δα au début de cette démonstration.
′
Comme t′ (ρ · r) = t(α · A)V on conclut à l’aide de l’égalité (3.3) que t′ est bien l’arbre des
exécutions selon F ′ .
La stratégie distribuée F ′ est gagnante pour (A′ , ϕ) dans le problème de synthèse avec
actions abstraites, donc t′ |= ϕ, donc, par le lemme 3.7, t |= ϕ, et F est une stratégie distribuée
gagnante pour (A, ϕ) dans le problème de synthèse général.
On a donc montré qu’on peut construire une architecture A′ du problème de synthèse avec
actions abstraites à partir d’une architecture A du problème de synthèse général, et que toute
stratégie distribuée gagnante pour le problème de synthèse général se traduit en une stratégie
distribuée gagnante pour le problème de synthèse avec actions abstraites (lemme 3.8). Par
ailleurs on a montré qu’on peut construire A, une architecture à synthétiser pour le problème
de synthèse général à partir de toute architecture A′ du problème de synthèse avec actions
abstraites, et qu’à nouveau toute stratégie distribuée gagnante pour A′ se traduit en une
stratégie distribuée gagnante pour A (lemme 3.9). Les hypothèses utilisées dans ces deux
lemmes permettent en fait de démontrer que chacun des problèmes se réduit à l’autre, ce qui
nous permet de conclure la preuve du théorème 3.5.
Il s’agit donc du même problème que celui énoncé en section 2.2, mais présenté de façon
plus concise : en effet, le déterminisme des actions de Σ combiné aux contraintes de la synthèse
entraı̂ne une démultiplication du nombre d’actions nécessaires à la modélisation.
Par la suite, on considérera de plus qu’une stratégie distribuée pour l’architecture A =
(Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) l’est parmi les variables en remarquant que pour tout p ∈
Proc, f p = (f v )v∈E(p) avec f v : (S R(v) )+ → S v où R = E −2 . Comme annoncé, on autorisera
également les processus à avoir des délais dans N, et on notera souvent dv pour dp , p ∈ E −1 (v).
La notion de délai arbitraire se traduit de façon beaucoup plus agréable dans ce modèle,
puisqu’elle est incluse dans la définition de d-compatibilité d’une stratégie (on reformule ici
la définition 3.2 en parlant de stratégies de variables) :
63
1. Le modèle
Définition 3.10 (Stratégie d-compatible). On dit qu’une stratégie f v : (S R(v) )+ → S v est
compatible avec son délai (ou d-compatible) si, pour tout i > 0, pour tous σ, σ ′ ∈ (S R(v) )i
tels que
σ[i − dv ] = σ ′ [i − dv ]
on a
f v (σ) = f v (σ ′ )
On dit que F = (f v )v∈V \VI est d-compatible si, pour tout v ∈ V \ VI , f v est d-compatible.
On reformule, pour être complet, le problème de synthèse tel qu’on va l’étudier dans ce
chapitre :
Définition 3.11 (Le problème de synthèse de système distribué synchrone à délais variables).
Étant données une architecture A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) et une spécification
ϕ ∈ L(VI ∪ VO ) (où L ∈ {LTL, CTL, CTL∗ }), existe-t-il une stratégie distribuée F = (f v )v∈V \VI
compatibles avec les délais telle que toute exécution F -compatible σ |= ϕ (telle que l’arbre des
exécutions selon F , t |= ϕ si ϕ est une formule branchante) ?
On dira qu’une telle stratégie distribuée est une stratégie distribuée gagnante pour (A, ϕ).
Par la suite, lorsque l’on parlera du problème de synthèse de système distribué synchrone (ou
problème de SSD synchrone), c’est à la variante précise définie ci-dessus (définition 3.11) que
l’on fera référence.
On considérera que, pour tout v ∈ V , |S v | ≥ 2 et {0, 1} ⊆ S v .
On utilisera par la suite également les notations et définitions suivantes :
Stratégies sans mémoire Pour v ∈ V \ VI , la stratégie f v est dite sans mémoire si
elle ne dépend pas du passé, c’est-à-dire, s’il existe une fonction g : S R(v) → S v telle que
f v (s1 · · · si · · · si+dv ) = g(si ), avec s1 · · · si · · · si+dv ∈ (S R(v) )+ . Dans le cas où dv = 0, cela
correspond à la définition habituelle de stratégie sans mémoire.
Résumés Pour une variable v ∈ V , on définit sa vue Vue(v) = (E −2 )∗ (v) ∩ VI comme
étant l’ensemble des variables modifiées par l’environnement dont v peut dépendre. En effet,
à stratégie distribuée fixée, la valeur d’une variable ne dépend que des choix non-déterministes
de l’environnement sur les variables auxquelles le processus en question a indirectement accès :
pour toute séquence σ ∈ (S V )ω exécution selon la stratégie F , pour tout v ∈ V \ VI , pour tout
i ≥ 0, svi ne dépend que de σ Vue(v) [i]. Ceci nous amène à définir la fonction correspondant à
la composition de toutes les stratégies locales utilisées pour calculer la valeur de la variable
v. On appelle résumé la fonction fˆv : (S Vue(v) )+ → S v vérifiant fˆv (σ Vue(v) [i]) = svi . Avec
cette notation, on peut caractériser les arbres d’exécutions selon une stratégie distribuée F =
(f v )v∈V \VI par les arbres d’exécutions t tels que, pour tout ρ ∈ (S VI )+ , t(ρ)v = fˆv (ρVue(v) ),
pour tout v ∈ V \ VI .
Délai cumulatif minimal Dans ce chapitre, on utilisera la notion de délai cumulatif minimal de transmission d’information de u à v. Il est défini par d(u, u) = 0, d(u, v) = ∞ si
v∈
/ (E 2 )+ (u), c’est-à-dire s’il n’y a pas de chemin de u à v dans le graphe de communication
de l’architecture, et, pour tout u 6= v ∈ (E 2 )+ (u),
d(u, v) = dv + min{d(u, w) | w ∈ R(v) et w ∈ (E 2 )∗ (u)}.
64
Chapitre 3. Synthèse de systèmes synchrones
d-compatibilité pour les résumés La compatibilité avec les délais de la stratégie distribuée F = (f v )v∈V \VI s’étend aux résumés F̂ = (fˆv )v∈V \VI . Formellement, on dit qu’une
application h : (S Vue(v) )+ → S v est d-compatible (ou compatible avec les délais (dv )v∈V \VI ) si
pour tout ρ ∈ (S Vue(v) )i , h(ρ) ne dépend que des préfixes (ρu [i − d(u, v)])u∈Vue(v) .
2
Architectures à information incomparable
Comme expliqué dans l’introduction de ce chapitre, le critère de décidabilité de [FS05]
ne peut pas s’appliquer lorsque l’on se restreint aux spécifications externes. En particulier, il
établit des conditions trop fortes sur les architectures pour la décidabilité du problème.
Dans cette section, on définit une condition suffisante d’indécidabilité pour le problème
de synthèse avec spécifications externes.
Définition 3.12 (Architecture à information incomparable). On dit qu’une architecture A =
(Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) est à information incomparable s’il existe deux variables
de sortie x, y ∈ VO telles que Vue(x)\Vue(y) 6= ∅ et Vue(y)\Vue(x) 6= ∅. Dans le cas contraire,
on dit que l’architecture est à information linéairement préordonnée.
Une architecture ordonnée telle que définie dans [FS05, BJ06] (voir définition 2.37) est
nécessairement à information linéairement préordonnée, mais la réciproque n’est pas vraie
(voir la figure 3.3 pour des exemples d’architectures ordonnées, à information incomparable,
à information linéairement préordonnée).
Il a été prouvé dans [PR90, FS05] que l’architecture A′ reproduite figure 3.4 est indécidable
pour les spécifications LTL et CTL dans le cas de processus 0-délai. On étend à présent ce
résultat, en montrant que toute architecture à information incomparable est indécidable. Tout
d’abord, il faut démontrer que le problème SSD synchrone est indécidable pour l’architecture
A′ dessinée figure 3.4 dans laquelle on considère des délais arbitraires pour p1 et p2 . Il suffit
simplement d’adapter la démonstration de [PR90] pour les cas LTL et CTL, afin que les
spécifications tiennent compte des délais des processus.
Théorème 3.13. Le problème de SSD synchrone est indécidable pour les architectures à
délais arbitraires et les spécifications externes de LTL ou CTL.
Démonstration.
On démontre le résultat pour les spécifications LTL. Si l’idée est similaire
à celle de [PR90], on présente ici une réduction légèrement différente de celle habituellement
utilisée. Par ailleurs, cela fournit une démonstration entièrement formalisée de ce résultat,
dont seules les idées de preuve figuraient dans [Ros92].
Pour une machine de Turing M , on définit une spécification LTL ϕM et on va réduire le
problème du non-arrêt de M sur bande vide au problème de synthèse de système distribué synchrone pour (A′ , ϕM ). Soit donc A′ = (Proc′ , V ′ , E ′ , (S ′v )v∈V ′ , s′0 , (dp )p∈Proc′ ) l’architecture
représentée sur la figure 3.4, dans laquelle S ′x0 = S ′y0 = {0, 1}, et S ′xn = S ′ym = Γ ⊎ Q ⊎ {#}
avec # un symbole distinct de ceux de Γ et Q. Les alphabets Γ et Q sont respectivement les
alphabets de bande et l’ensemble d’états de M . On considère que s′v
0 = 0 pour v ∈ {x0 , y0 }
et s′v
=
#
pour
v
∈
{x
,
y
}.
On
suppose
que
d
≤
d
.
n m
p1
p2
0
Une configuration de la machine de Turing définie par un état q et un contenu de bande
γ1 γ2 , avec la tête de lecture située sur le premier symbole de γ2 est représentée par le mot
γ1 qγ2 ∈ Γ∗ QΓ+ (on impose que γ2 soit non vide pour des raisons techniques, si besoin on
peut rajouter des symboles blancs). Une séquence de valeurs prises par la variable x0 , σ x0 ∈
65
2. Architectures à information incomparable
x0
x1
x2
p0
p1
x4
x5
x3
p2
p3
x6
x7
(a) Une architecture à information incomparable
x0
x1
x2
p0
p1
p2
x1
x2
x3
x4
p1
p2
p3
p4
y0
x3
x4
x5
x6
x0
p1
x1
p2
x2
x4
x3
(b) Des architectures à information linéairement préordonnée mais non ordonnées
(c) Une architecture ordonnée
Fig. 3.3 – Exemples d’architectures à information incomparable ou linéairement préordonnée
0∗ 1p 0{0, 1}ω , code l’entier n(x0 ) = p. On prend le même codage pour la variable y0 . On
construit donc une spécification LTL ϕM forçant toute stratégie distribuée gagnante à écrire
sur la variable xn la n(x0 )-ième configuration de M lorsqu’elle commence sur la bande vide.
La spécification ϕM est une conjonction des propriétés décrites ci-dessous.
1. Si la séquence de valeurs prises par x0 (respectivement par y0 ) est dans 0q 1p 0{0, 1}ω ,
alors la séquence des valeurs prises par xn est dans #dp1 +q+p Γ∗ QΓ+ #ω (respectivement
ym est dans #dp2 +q+p Γ∗ QΓ+ #ω ). Ceci est formalisé par la formule α ∈ LTL(V ′ I ∪ V ′ O ) :
α = αx0 ,xn,dp1 ∧ αy0 ,ym ,dp2
où
def
αz,t,d = ((z = 0) ∧ (t = #)) W (((z = 1) ∧ (t = #)) W ((z = 0) ∧ t ∈ #d Γ∗ QΓ+ #ω ))
66
Chapitre 3. Synthèse de systèmes synchrones
où t ∈ #d Γ∗ QΓ+ #ω signifie
(t = #) Ud ((t ∈ Γ) U (t ∈ Q) ∧ X((t ∈ Γ) U ((t ∈ Γ) ∧ X G(t = #))))
avec
def
ϕ Ui ψ = ϕ ∧ (X ϕ) ∧ · · · ∧ (Xi−1 ϕ) ∧ X i ψ
pour tout i > 0, et
def
ϕ U0 ψ = ψ
2. Si la séquence de valeurs prises par x0 est dans 0q 10{0, 1}ω , i.e., n(x0 ) = 1, alors la
séquence de valeurs prises par xn doit être #dp1 +q+1 C1 #ω , i.e., elle doit correspondre à
C1 , la première configuration de M commençant sur bande vide. On décrit formellement
β:
def
β = (x0 = 0) W ((x0 = 1) ∧ X((x0 = 0) → (x ∈ #dp1 C1 #ω )))
où x ∈ #dp1 C1 #ω s’exprime simplement.
3. On dit que, dans une exécution σ ∈ (S V )ω , les mots d’entrée sont synchronisés si, soit
σ x0 , σ y0 ∈ 0q 1p 0{0, 1}ω (i.e., les séquences sur x0 et y0 codent le même entier, et de la
même façon), soit σ x0 ∈ 0q 1p+1 0{0, 1}ω et σ y0 ∈ 0q+1 1p 0{0, 1}ω (i.e., n(x0 ) = n(y0 ) + 1,
mais le codage « finit » au même moment). La formule γ exprime le fait que, si les
mots d’entrée sont synchronisés, et que n(x0 ) = n(y0 ), alors les séquences écrites sur xn
et ym sont identiques, au décalage dû à leurs délais respectifs près. On commence par
exprimer le fait que n(x0 ) = n(y0 ) :
def
(n(x0 ) = n(y0 )) = (x0 = y0 = 0) U ((x0 = y0 = 1) ∧ (x0 = y0 = 1) U (x0 = y0 = 0))
La formule γ est définie par
def
γ = (n(x0 ) = n(y0 )) → G(Egal(xn , ym ))
où Egal(xn , ym ) exprime le fait que les valeurs de xn et ym sont égales, au décalage de
leurs délais près :
_
Egal(x, y) =
((x = i) ∧ Xdp2 −dp1 (y = i))
i∈Γ⊎Q⊎{#}
4. Enfin, on exprime avec la formule δ que si x0 et y0 sont synchronisés, et que n(x0 ) =
n(y0 )+ 1, alors on veut que la configuration codée sur xn soit la configuration successeur
dans l’exécution de la machine de Turing M de celle encodée sur ym , encore une fois, en
tenant compte du décalage dû à leurs délais respectifs. On utilise la formule (n(x0 ) =
n(y0 ) + 1) définie par
(x0 = y0 = 0) U ((x0 = 1) ∧ (y0 = 0) ∧ X((x0 = y0 = 1) ∧ (x0 = y0 = 1) U (x0 = y0 = 0)))
La formule δ est donc
δ = (n(x0 ) = n(y0 ) + 1) → (Egal(xn , ym ) U (Trans(ym , xn ) ∧ X3 G Egal(xn , ym )))
67
2. Architectures à information incomparable
où Trans(y, x) exprime le fait que le facteur de trois lettres de x est obtenu à partir de
celui de y en effectuant une transition de la machine de Turing M . On a
_
Trans(y, x) =
(Xdp2 −dp1 (y = cpa)) ∧ (x = qcb)
(p,a,q,b,←)∈T,c∈Γ
∨
_
(Xdp2 −dp1 (y = pac)) ∧ (x = bqc)
(p,a,q,b,→)∈T,c∈Γ
∨
_
(Xdp2 −dp1 (y = pa#)) ∧ (x = bq)
(p,a,q,b,→)∈T
On utilise l’abréviation (x = abc) pour (x = a) ∧ X(x = b) ∧ X2 (x = c). De plus, est le symbole vide de la bande et T est l’ensemble des transitions de M (la transition
(p, a, q, b, dir ), prise quand M est dans l’état p avec la tête de lecture sur le symbole a,
change l’état de la machine en q, écrit sur la bande le symbole b et déplace la tête de
lecture dans la direction dir ∈ {←, →}).
La spécification ϕM est donc ϕM = α ∧ β ∧ γ ∧ δ
Il est clair que la stratégie d-compatible qui écrit une séquence de # sur sa variable jusqu’à
ce que la séquence 0q 1p 0 ait été jouée, puis écrit le codage de la p-ième configuration de la
machine de Turing est une stratégie gagnante pour (A′ , ϕM ).
On montre qu’il n’en existe pas d’autre : soit F = (f xn , f ym ) une stratégie distribuée
gagnante pour (A′ , ϕM ). Soit σ ∈ (S V )ω une exécution F -compatible. Alors, on montre par
récurrence sur p > 0, que
∀p > 0, ∀q ≥ 0, σ x0 ∈ 0q 1p 0{0, 1}ω =⇒ σ xn = #dp1 +q+p Cp #ω
(3.4)
Pour p = 1 la propriété (3.4) découle directement de la spécification (en particulier, des
formules α et β).
Soit p > 1. Supposons que σ x0 ∈ 0q 1p+1 0{0, 1}ω et σ y0 ∈ 0q+1 1p 0{0, 1}ω . On considère alors une autre exécution F -compatible, σ0 , telle que σ0x0 ∈ 0q+1 1p 0{0, 1}ω et σ0y0 =
σ y0 ∈ 0q+1 1p 0{0, 1}ω . Par hypothèse de récurrence, σ0xn = #dp1 +q+1+p Cp #ω . Comme F est
une stratégie gagnante, pour satisfaire ϕM , (et en particulier γ), on en déduit que σ0ym =
#dp2 +p+q+1 Cp #ω . De plus, σ0ym = σ ym . Or σ est tel que n(x0 ) = n(y0 )+1, donc pour satisfaire
la spécification (et en particulier la sous-formule δ), nécessairement σ xn = #dp1 +p+q+1 Cp+1 #ω .
Pour une machine de Turing M , on a montré que toute stratégie distribuée gagnante
pour (A′ , ϕM ) est contrainte d’écrire sur la variable xn la n(x0 )-ième configuration de M .
par conséquent, il existe une stratégie distribuée gagnante pour (A′ , ϕM ∧ G(xn 6= halt)) si
et seulement si M ne s’arrête pas lorsque son entrée est la bande vide. On a donc réduit le
problème du non-arrêt d’une machine de Turing au problème de SSD synchrone pour (A, ϕ)
avec A architecture avec délais arbitraires, et ϕ ∈ LTL(VI ∪ VO ), démontrant par là que ce
dernier problème est indécidable.
On donne à présent les idées nécessaires pour obtenir le résultat pour les spécifications
CTL : il faut adapter la formule ϕM pour la rendre exprimable en CTL. La formule utilise le
fait que, dans un arbre de stratégie modèle de la spécification, à partir du moment où on a
vu une séquence finie particulière de la forme 0q 1p 0 sur x0 , alors toutes les branches partant
de ce nœud ont les mêmes contraintes sur xn (et respectivement pour y0 et ym ). La formule
suivante permet d’obtenir le résultat :
ϕ=α∧β∧γ
68
Chapitre 3. Synthèse de systèmes synchrones
où
1. la formule α correspond à la formule α de LTL précédemment décrite, dans laquelle
on décrit maintenant les différentes branches des arbres de stratégies que l’on veut
accepter : la projection de l’étiquette de toute branche sur sa composante x0 (respectivement y0 ) est une séquence de 0 et de 1, et sur les branches pour lesquelles cette
séquence vaut 0q 1p 0{0, 1}ω , alors les valeurs prises par xn (respectivement ym ) sont
dans #dp1 +q+p Γ∗ QΓ+ #ω . Soit formellement la formule α ∈ CTL(VI ′ ∪ VO ′ ) suivante :
α = αx0 ,xn,dp1 ∧ αy0 ,ym ,dp2
où
def
αz,t,d = A(z = 0∧t = #)W (z = 1∧t = #)∧(A(z = 1∧t = #)W((z = 0)∧Config(t, d)))
avec Config(t, d) exprimé par
A(t = #) Ud A(t ∈ Γ) U (t ∈ Q) ∧ AX(A(t ∈ Γ) U ((t ∈ Γ) ∧ AX AG(t = #)))
et
A ϕ U0 ψ = ψ
A ϕ Ui ψ = ϕ ∧ AX ϕ ∧ · · · ∧ ((AX)i−1 ϕ) ∧ ((AX)i ψ)
2. la formule β correspond également à la formule β de la formule LTL que l’on a donnée au
début de la démonstration : toutes les branches des modèles que l’on cherche vérifient
la propriété suivante : soit la séquence de valeurs prises par x0 ne vérifie pas n(x0 ) = 1,
soit la séquence de valeurs prise par xn doit correspondre à C1 . Soit :
def
β = A(x0 = 0) W (x0 = 1) ∧ AX (x0 = 1) ∨ ((x0 = 0) ∧ A(x ∈ #dp1 C1 #ω ))
dans laquelle A(x ∈ #dp1 C1 #ω ) est la formule CTL reprenant la formule de chemin
x ∈ #dp1 C1 #ω où on a remplacé les modalités X et U respectivement par AX et A U.
3. la formule γ reprend les formules γ et δ de la spécification LTL. Elle décrit à nouveau
toutes les branches de l’arbre que l’on cherche : soit les séquences de valeurs prises par
x0 et y0 ne sont pas synchronisées, soit elles sont synchronisées et n(x0 ) = n(y0 ) et alors
les valeurs prises par xn et ym sur tous les états accessibles à partir de ce moment sont
les mêmes (mais la spécification α implique qu’en fait les séquences de valeurs prises
par xn et ym sont les mêmes sur toute les branches initiales concernées), soit elles sont
synchronisées et n(x0 ) = n(y0 ) + 1 et alors, sur toutes les branches correspondant à
ce cas de figure, la configuration codée sur xn est la configuration successeur de celle
encodée sur ym , au décalage de leurs délais près. Soit :
def
γ = A(x0 = y0 = 0) W (x0 = 0 ∧ y0 = 1)∨
(x0 = y0 = 1) ∧ AX(A(x0 = y0 = 1) W ((x0 6= y0 )∨
SyncEgal(x0 , y0 , xn , ym ))) ∨
(x0 = 1 ∧ y0 = 0) ∧ EX((x0 = y0 = 1) ∧ AX(A(x0 = y0 = 1)
W ((x0 6= y0 ) ∨ SyncDecal(x0 , y0 , xn , ym ))))
69
2. Architectures à information incomparable
avec
_
SyncEgal(x, y, z, t) = (x = y = 0) ∧ AG
i∈Γ⊎Q⊎{#}
((z = i) ∧ (AX)dp2 −dp1 (t = i))
et
SyncDecal(x, y, z, t) = (x = y = 0)∧ A
_
((z = i) ∧ (AX)dp2 −dp1 (t = i)) U
i∈Γ⊎Q⊎{#}
A Trans(t, z)∧
_
AX3 AG(
((z = i) ∧ (AX)dp2 −dp1 (t = i))) .
i∈Γ⊎Q⊎{#}
et A Trans(t, z) la formule Trans(t, z) définie dans le cas LTL et dans laquelle on remplace
les modalités X par AX.
Ainsi, si on considère une stratégie gagnante pour (A′ , ϕ) dont l’arbre des exécutions est
′
′
t : (S ′VI )∗ → S ′V , on peut montrer que, si on prend une branche initiale finie de t étiquetée
par 0q 1p 0 sur sa composante x0 alors toutes les branches infinies ayant ce segment initial sont
étiquetées par #dp1 +p+q Cp #ω sur leur composante xn . Une fois de plus, on peut le démontrer
par récurrence, le cas de base étant assuré par α et β. Si on considère ensuite une branche
de t étiquetée par 0q 1p+1 0{0, 1}ω sur sa composante x0 , alors l’hypothèse de récurrence nous
assure que toutes les branches étiquetées par une séquence dans 0q+1 1p 0{0, 1}ω sur x0 et
0q+1 1p 0{0, 1}ω sur y0 sont étiquetées par #dp1 +p+q+1 Cp #ω sur xn . Donc la formule γ impose
que ces branches soient étiquetées par #dp2 +p+q+1 Cp #ω sur ym . Cela implique, la stratégie
pour ym ne dépendant que de y0 , que toutes les branches étiquetées par 0q+1 1p 0{0, 1}ω sur y0
sont étiquetées par #dp2 +p+q+1 Cp #ω sur ym . Puis, la formule γ impose à nouveau que toutes
les branches étiquetées par 0q 1p+1 0{0, 1}ω sur x0 et 0q+1 1p 0{0, 1}ω sur y0 soient étiquetées
par #dp1 +p+q+1 Cp+1 #ω sur xn . Le fait que la stratégie de xn ne dépende que de x0 permet
de conclure.
On montre à présent que le fait d’être à information incomparable est une condition
suffisante pour entraı̂ner l’indécidabilité du problème de SSD synchrone pour les spécifications
externes.
Proposition 3.14. Le problème de SSD synchrone est indécidable pour les architectures à
information incomparable et les spécifications externes de LTL ou CTL.
Pour toute architecture A à information incomparable, on réduit le problème de SSD
synchrone pour (A′ , ϕ) avec ϕ spécification externe de LTL ou CTL au problème de SSD
synchrone pour (A, ϕ) avec ϕ spécification externe de LTL ou CTL. Si le fait qu’il existe
une réduction n’est pas surprenant, la démonstration n’est pas complètement immédiate. En
particulier, la spécification utilisée doit être modifiée au cours de la réduction. La fin de cette
section est consacrée à la preuve de la proposition 3.14.
Considérons maintenant A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) une architecture à information incomparable. Sans perte de généralité, on peut considérer que sv0 = 0 pour tout
v ∈ V . Par définition, on peut trouver deux variables de sortie xn et ym ∈ VO et deux variables
d’entrée x0 ∈ Vue(xn ) et y0 ∈ Vue(ym ) telles que x0 ∈
/ Vue(ym ) et y0 ∈
/ Vue(xn ). On considère
2
2
2
2
2
deux chemins x0 E x1 E . . . E xn allant de x0 à xn et y0 E y1 E . . . E 2 ym allant de y0 à ym
70
Chapitre 3. Synthèse de systèmes synchrones
y0
x0
ym
xn
x0
y0
p1
p2
xn
ym
A′
A
Fig. 3.4 – Architectures A and A′
vérifiant d(x0 , xn ) = dx1 + · · · + dxn et d(y0 , ym ) = dy1 + · · · + dym . Par ailleurs, les ensembles
{x0 , . . . , xn } et {y0 , . . . , ym } sont disjoints.
Soit A′ = (Proc′ , V ′ , E ′ , (S ′v )v∈V ′ , s′0 ) l’architecture de la figure 3.4, avec VI ′ = {x0 , y0 } et
′
VO = {xn , ym } ; avec les mêmes domaines de variables de sortie S ′xn = S xn et S ′ym = S ym ;
′
avec S ′x0 = S ′y0 = {0, 1} pour domaines de variables d’entrée ; et avec s′0 = sV0 . Les délais
des processus (d′p )p∈Proc′ sont les délais cumulatifs minimaux de transmission d’information
de x0 à xn et de y0 à ym : d′p1 = d′xn = d(x0 , xn ) et d′p2 = d′ym = d(y0 , ym ).
On sait que le problème SSD synchrone est indécidable pour (A′ , ϕ) avec ϕ spécification
LTL ou CTL (théorème 3.13). On présente maintenant la réduction. Considérons d’abord les
spécifications CTL.
Remarquons tout d’abord qu’il est nécessaire de modifier la spécification au cours de la
réduction. En effet, si on considère
ψ = EG((x0 = 0) ∧ (xn = 0)) ∧ EG((x0 = 0) ∧ (xn = 1)))
il existe une stratégie distribuée gagnante pour (A, ψ) (pourvu que Vue(xn ) \ {x0 } =
6 ∅
et que tous les délais soient nuls), mais pas pour (A′ , ψ) : dans A, la valeur de xn peut être
déterminée par la valeur d’une variable de Vue(xn ) \ {x0 }, tandis que dans A′ , la stratégie
contrôlant xn ne peut dépendre que de x0 .
Afin de définir une stratégie gagnante F ′ pour A′ à partir d’une stratégie gagnante F pour
A, on va simuler sur A′ le comportement de F lorsque toutes les variables d’entrée différentes
de VI ′ = {x0 , y0 } valent 0 de façon constante au long de l’exécution. Pour cela nous allons
contraindre le comportement des processus de A en transformant la spécification
au cours de la
V
réduction, par l’utilisation de la formule
χ
=
(x
∈
{0,
1})∧(y
∈
{0,
1})∧
0
0
v∈VI \V ′ I (v = 0), où
W
x ∈ I est une abbréviation pour i∈I (x = i). On définit à présent la réduction d’une formule
ψ ∈ CTL(V ′ ) en une formule ψ ∈ CTL(V ) imposant ψ sur le sous-arbre des exécutions vérifiant
χ:
(x = s) = (x = s)
ϕ∨ψ =ϕ∨ψ
E ϕ U ψ = E(χ ∧ ϕ) U (χ ∧ ψ)
¬ψ = ¬ψ
EX ψ = EX(χ ∧ ψ)
EG ψ = EG(χ ∧ ψ)
71
2. Architectures à information incomparable
′
′
On utilise la notation suivante : pour tout r ∈ S ′VI , on définit r ∈ S VI par rVI = r et
v
r = 0 pour tout v ∈ VI \ VI ′ . On étend cette notation aux mots, en prenant ε = ε. Ceci
′
′
nous permet de définir un arbre d’exécutions t̃ : (S ′VI )∗ → S V sur A′ à partir d’un arbre
′
′
d’exécutions t : S VI → S V sur A, en posant, pour tout ρ ∈ (S ′VI )∗ , t̃(ρ) = t(ρ)V . L’arbre t̃
représente donc les exécutions sur A dans lesquelles tous les v ∈ VI \ VI ′ valent 0. La réduction
de la formule est correcte dans le sens suivant :
Lemme 3.15. Pour toute formule ψ ∈ CTL(V ′ ), pour tout arbre t : (S VI )∗ → S V et pour
′
tout ρ ∈ (S ′VI )∗ , t, ρ |= ψ si et seulement si t̃, ρ |= ψ.
Démonstration.
Par récurrence sur la structure de la formule ψ. Soit t : (S VI )∗ → S V ,
′
et soit ρ ∈ (S ′VI )∗ .
Si ψ = (x = s), avec x ∈ V ′ et s ∈ S x , alors le résultat se déduit du fait que t̃(ρ)x = t(ρ)x .
Les cas où ψ = ¬ϕ ou ψ = ψ1 ∨ ψ2 sont triviaux.
Soit maintenant ψ = E ψ1 U ψ2 et supposons que t, ρ |= ψ. Alors il existe s1 · · · sn ∈ (S VI )∗
tels que t, ρ · s1 · · · sn |= χ ∧ ψ2 et t, ρ · s1 · · · si |= χ ∧ ψ1 , pour tout 0 ≤ i < n. Comme
′
′
t, ρ · s1 · · · si |= χ, alors si = ri avec ri = sVi I ∈ S ′VI . En appliquant l’hypothèse de récurrence,
on obtient que t̃, ρ · r1 · · · ri |= ψ1 pour tout 0 ≤ i < n, et t̃, ρ · r1 · · · rn |= ψ2 , donc que
′
t̃, ρ |= ψ. Réciproquement, supposons que t̃, ρ |= ψ. Alors il existe r1 · · · rn ∈ (S ′VI )∗ tels que
t̃, ρ · r1 · · · rn |= ψ2 et t̃, ρ · r1 · · · ri |= ψ1 , pour tout 0 ≤ i < n. Par hypothèse de récurrence,
on en déduit que t, ρ · r1 · · · rn |= ψ2 , et que t, ρ · r1 · · · ri |= ψ1 , pour tout 0 ≤ i < n. De plus,
′
par construction, pour tout 0 ≤ i ≤ n, t(ρ · r1 · · · ri )VI ∈ {0, 1} et pour tout v ∈ VI \ VI ′ ,
t(ρ · r1 · · · ri )v = 0. Donc en posant si = ri pour tout 1 ≤ i ≤ n, on obtient qu’il existe
s1 , · · · , sn ∈ S VI tels que t, ρ · s1 · · · sn |= χ ∧ ψ2 et t, ρ · s1 · · · si |= χ ∧ ψ1 , pour tout 0 ≤ i < n,
et donc que t, ρ |= ψ1 U ψ2 .
Les cas EX et EG s’obtiennent de la même façon.
On prouve à présent la réduction proprement dite :
Lemme 3.16. S’il existe un programme distribué F ′ gagnant pour (A′ , ψ), alors il existe un
programme distribué F gagnant pour (A, ψ).
Démonstration.
Fixons F ′ = (f ′xn , f ′ym ) une stratégie distribuée gagnante pour (A′ , ψ).
On va définir une stratégie distribuée F = (f v )v∈V \VI gagnante pour (A, ψ) telle que la projection sur V ′ d’une exécution F -compatible soit une exécution F ′ -compatible. Plus précisément,
si σ ∈ (S V )+ est un préfixe d’une exécution selon F vérifiant σ x0 ∈ {0, 1}+ et σ y0 ∈ {0, 1}+ ,
alors on veut que les égalités suivantes soient vérifiées :
f xn (σ R(xn ) ) = f ′xn (σ x0 )
f
ym
(σ
R(ym )
) = f ′ym (σ y0 )
(3.5)
(3.6)
Pour cela, on va utiliser les variables x1 , . . . , xn−1 pour transmettre les valeurs de x0 au
processus écrivant sur xn . Formellement, la stratégie f xk recopie sur xk la dernière valeur de
xk−1 dont elle dépend : celle écrite dxk instants auparavant. Pour 0 < k < n et τ ∈ (S R(xk ) )+ ,
on définit donc
(
sxk−1 si τ = τ1 sτ2 avec |τ2 | = dxk et sxk−1 ∈ {0, 1}
k
f x (τ ) =
0
sinon.
72
Chapitre 3. Synthèse de systèmes synchrones
x0
d′xn
x
xn−1
σ2 n−1
d′xn − dxn
dxn
Fig. 3.5 – Simulation de f ′xn par f xn .
Par définition, f xk est bien d-compatible. On peut vérifier facilement que si la séquence de
valeurs prises par x0 est ρ ∈ {0, 1}ω , en respectant les stratégies f xk définies ci-dessus, les
valeurs prises par xn−1 sont 0d(x0 ,xn−1 ) ρ où la séquence initiale de 0 correspond au décalage
induit par le délai de transmission d(x0 , xn−1 ) = d′xn − dxn .
Afin de satisfaire (3.5), la dernière stratégie f xn simule f ′xn en tenant compte du décalage
de d′xn − dxn unités de temps de leurs délais respectifs. Considérons une séquence σ ∈ (S V )+
compatible avec les stratégies (f xk )0<k<n telle que σ x0 ∈ {0, 1}+ . Si |σ| ≤ d′xn , alors f ′xn (σ x0 )
ne dépend pas de σ, et on définit f xn (σ R(xn ) ) = f ′xn (0|σ| ) = f ′xn (σ x0 ), et l’égalité (3.5) est
vérifiée. Si maintenant σ = σ1 σ2 σ3 , avec |σ1 | = d′xn −dxn , |σ3 | = dxn , alors f ′xn (σ x0 ) ne dépend
x
que de son préfixe de taille |σ2 | = i. On remarque que σ[i]x0 = σ2 n−1 (voir la figure 3.5), donc
′
x
n−1
d
x
′x
R(x
)
′x
x
on pose dans ce cas f n (σ n ) = f n (σ2 0 xn ) = f n (σ 0 ) et (3.5) est vérifiée. On définit
donc f xn formellement, pour tout τ ∈ (S R(xn ) )+ , par


f ′xn (0|τ | )



f ′xn (τ xn−1 0d′xn )
2
xn
f (τ ) =




0
si |τ | ≤ d′xn ,
si τ = τ1 τ2 τ3 tels que |τ1 | = d′xn − dxn , |τ3 | = dxn
x
et τ2 n−1 ∈ {0, 1}+ ,
sinon.
Il est clair que f xn est compatible avec le délai dxn , et que l’égalité (3.5) est vérifiée avec
cette définition des stratégies (f xk )0<k≤n . On définit de façon similaire les stratégies f yk ,
pour 0 < k ≤ m, et pour toutes les autres variables v, on pose f v = 0. On obtient une
stratégie distribuée F compatible avec les délais, pour laquelle il reste à montrer qu’elle est
bien gagnante pour (A, ψ).
Soit t : (S VI )∗ → S V l’arbre d’exécutions respectant F sur A. On va montrer que t̃ :
′
′
(S ′VI )∗ → S V est l’arbre d’exécutions respectant F ′ sur A′ . Ainsi, comme F ′ est une stratégie
distribuée gagnante pour (A′ , ψ), t̃, ε |= ψ donc, par le lemme 3.15, t, ε |= ψ, et F est une
stratégie distribuée gagnante pour (A, ψ).
Montrons à présent que t̃ est bien l’arbre d’exécutions respectant F ′ . Tout d’abord, il est
′
′
facile de voir que t̃ est un arbre d’exécutions sur A′ : t̃(ε) = t(ε)V = sV0 = s′0 , et pour tout
′
′
′
′
′
ρ ∈ (S VI )∗ , tout r ∈ S VI , t̃(ρ · r)VI = t(ρ · r)VI = r VI = r. Pour montrer que c’est bien l’arbre
′
des exécutions respectant F ′ , on doit encore montrer que, pour tout ρ = r1 · · · ri ∈ (S ′VI )+ ,
t̃(ρ)xn = f ′xn (ρx0 ) et t̃(ρ)ym = f ′ym (ρx0 ). Soit σ ∈ (S V )+ l’exécution respectant F induite
par la séquence d’entrée ρ : σ = t(ε)t(r1 )t(r1 r2 ) · · · t(ρ). En utilisant le fait que (3.5) est
vérifié, on obtient t̃(ρ)xn = t(ρ)xn = f xn (σ R(xn ) ) = f ′xn (σ x0 ) = f ′xn (ρx0 ). En utilisant les
mêmes arguments, on obtient que t̃(ρ)ym = f ′ym (ρy0 ), et donc que t̃ est l’arbre des exécutions
respectant F ′ .
Lemme 3.17. S’il existe un programme distribué F gagnant pour (A, ψ), alors il existe un
programme distribué F ′ gagnant pour (A′ , ψ).
2. Architectures à information incomparable
73
Démonstration.
Fixons F = (f v )v∈V \VI une stratégie distribuée gagnante pour (A, ψ).
′x
On va définir f n : (S ′x0 )+ → S ′xn et f ′ym : (S ′y0 )+ → S ′ym les stratégies pour les variables de
A′ . La difficulté supplémentaire réside ici dans le fait que f ′xn a en général moins de variables
d’entrée que fˆxn , donc on ne peut pas simuler directement les stratégies de A. Pour résoudre
ce problème, on va utiliser le fait que, de par la forme particulière de ψ, l’arbre des exécutions
respectant F satisfait ψ si et seulement si le sous-arbre restreint aux branches pour lesquelles
la valeur de toutes les variables d’entrée v ∈ V \ {x0 , y0 } est toujours 0 satisfait aussi ψ
(lemme 3.15). Les processus de A′ vont donc se comporter comme ceux écrivant sur xn et ym
dans A dans les exécutions particulières où toutes les variables d’entrée différentes de x0 et
y0 valent constamment 0.
′
Formellement, pour ρ ∈ (S ′VI )+ , on pose f ′xn (ρx0 ) = fˆxn (ρVue(xn ) ). Remarquons que,
comme A est à information incomparable, y0 ∈
/ Vue(xn ) et donc fˆxn ne dépend pas de
ρy0 . Donc f ′xn ne dépend que de ρx0 et f ′xn est une stratégie à mémoire locale pour xn
dans l’architecture A′ . De plus, f xn est d-compatible, donc, comme d′xn = d(x0 , xn ), f ′xn est
également d-compatible. On définit f ′ym de façon similaire et on vérifie que F ′ = (f ′xn , f ′ym )
est bien une stratégie gagnante pour (A′ , ψ). Soit t l’arbre des exécutions de F sur A et t′
l’arbre des exécutions de F ′ sur A′ . Alors t′ (ρ)xn = f ′xn (ρx0 ) = fˆxn (ρVue(xn ) ) = t(ρ)xn =
t̃(ρ)xn et, de la même façon, t′ (ρ)ym = t̃(ρ)ym . Donc t′ = t̃. De plus, t, ε |= ψ, donc, par le
lemme 3.15, t′ , ε |= ψ et F ′ est bien une stratégie distribuée gagnante pour (A′ , ψ).
On prouve maintenant le résultat pour les spécifications LTL. Dans ce cas, la spécification
sur A doit juste assurer que les valeurs des variables x0 et y0 restent dans le domaine autorisé
dans A′ au cours de l’exécution. On va utiliser la réduction
ψ = (G ξ) → ψ
où la formule ξ est définie par ξ = (x0 ∈ {0, 1}) ∧ (y0 ∈ {0, 1}).
On utilise les mêmes constructions que celles décrites dans les lemmes 3.16 et 3.17 pour
obtenir la réduction. En effet, soit F ′ une stratégie distribuée gagnante pour (A′ , ψ) et soit
F la stratégie distribuée définie dans la preuve du lemme 3.16. Soit σ = s0 s1 · · · ∈ (S V )ω une
exécution respectant la stratégie F et soit ρ = σ VI sa projection sur les variables d’entrée. Si
ρx0 ∈
/ {0, 1}ω ou ρy0 ∈
/ {0, 1}ω , alors σ 6|= G ξ. Sinon, par les égalités (3.5) et (3.6), on obtient
xn
x
n
pour i > 0, si = f (σ R(xn ) [i]) = f ′xn (σ x0 [i]) et syi m = f ym (σ R(ym ) [i]) = f ′ym (σ y0 [i]). On en
′
′
déduit que σ V est une exécution respectant F ′ , et donc σ V |= ψ. Comme ψ ∈ LTL(V ′ ), on a
σ |= ψ. On en conclut que toute exécution σ respectant F est telle que σ |= G ξ → ψ et donc
que F est une stratégie distribuée gagnante pour (A, ψ).
Réciproquement, pour F stratégie distribuée gagnante pour (A, ψ), on définit F ′ comme
′
′
dans la preuve du lemme 3.17. Soit ρ ∈ (S ′VI )ω une séquence de valeurs d’entrée et σ ′ ∈ (S ′V )ω
l’exécution F ′ -compatible induite. Soit σ = s0 s1 · · · ∈ (S V )ω l’exécution respectant F telle
que σ VI = ρ. Par définition, σ |= G ξ, et donc, comme F est une stratégie distribuée gagnante
′
pour (A, ψ), alors σ |= ψ. À nouveau, comme ψ ∈ LTL(V ′ ), cela implique que σ V |= ψ. On
′
obtient immédiatement des définitions de f ′xn et f ′ym que σ V est une exécution respectant
′
′
F ′ . Par ailleurs σ VI = ρ donc σ V = σ ′ . On en conclut que F ′ est une stratégie distribuée
gagnante pour (A′ , ψ).
On a donc défini une réduction du problème de SSD synchrone avec spécifications de LTL
ou CTL sur l’architecture A′ au même problème sur une architecture avec information incomparable. Comme le problème de synthèse est indécidable à la fois pour des spécifications LTL
et CTL sur A′ , on obtient son indécidabilité pour les architectures à information incomparable.
74
3
Chapitre 3. Synthèse de systèmes synchrones
Architectures uniformément bien connectées
Dans cette section, on introduit une nouvelle classe d’architectures : les architectures
uniformément bien connectées (UWC), et on fournit un critère de décidabilité pour le problème
de SSD synchrone pour cette classe. On montre également qu’il est décidable de déterminer
si une architecture donnée est UWC, et on donne la complexité de ce problème. Enfin on
introduit la notion de spécification robuste et on montre que les architectures UWC sont
toutes décidables pour ces spécifications. Informellement, une architecture est UWC si on
peut transmettre à chaque instant aux processus modifiant les variables de sortie toutes les
valeurs de variables dans leur vue. Si le domaine des variables internes est arbitrairement
grand, on se convainc facilement que toutes les architectures sont UWC. Ceci sera prouvé à
la section suivante.
3.1
Définition
Un routage pour une architecture distribuée A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) est
une famille de stratégies locales sans mémoire Φ = (f v )v∈V \(VI ∪VO ) . On remarque qu’un
routage ne comprend pas de stratégies pour les variables de sortie du système. On dit qu’une
architecture est uniformément bien connectée (UWC) s’il existe un routage Φ qui permet de
transmettre avec un délai minimal au processus modifiant une variable v ∈ VO toutes les
valeurs des variables de Vue(v). Formellement,
Définition 3.18. Une architecture A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) est uniformément
bien connectée (UWC), s’il existe un routage Φ et, pour chaque variable de sortie v ∈ VO et
chaque variable d’entrée u ∈ Vue(v), une fonction de décodage gu,v : (S R(v) )+ → S u qui
permet de reconstruire la valeur de u, c’est-à-dire telle que, pour toute séquence σ = s1 · · · ∈
(S V \VO )+ Φ-compatible, on a, pour i ≥ 1,
sui = gu,v (σ R(v) [i + d(u, v) − dv ])
(3.7)
Remarque 3.19. On n’inclut pas l’état initial dans la séquence. En effet, les processus n’ont
pas besoin de le décoder pour le connaı̂tre.
Dans le cas d’une architecture sans délai, la notion d’architecture uniformément bien
connectée raffine la notion de connectivité adéquate introduite par Pnueli et Rosner [PR90],
puisqu’on n’impose plus de transmettre à chaque variable de sortie la valeur de toutes les
variables d’entrée, mais uniquement de celles appartenant à sa vue. (Si les variables ont toutes
le même domaine, les architectures représentées sur la sous-figure (3.3(b)) de la figure 3.3 sont
adéquatement connectées).
On note que, si les fonctions de routage sont sans mémoire, on autorise les fonctions de
décodage à tenir compte de leur passé ; en fait, la mémoire peut même être nécessaire pour
parvenir à reconstituer les valeurs des variables en entrée. En effet, considérons l’architecture
représentée dans la figure 3.6. Les délais sont indiqués à côté des processus, et le domaine de
toutes les variables est {0, 1}. Cette architecture est bien UWC : le processus p écrit sur la
variable t le résultat de l’addition modulo 2 (ou XOR) de u1 et u2 avec un délai de 1. On
va l’écrire t = Y u1 ⊕ Y u2 , avec Y x représentant la précédente valeur de la variable x. Afin
de reconstruire la valeur de Y u2 à partir de Y u1 ⊕ Y u2 , le processus q1 doit mémoriser la
précédente valeur de u1 et calculer le XOR de cette valeur avec la valeur de la variable t :
75
3. Architectures uniformément bien connectées
u1
u2
p 1
t
q1 0
0 q2
v1
v2
Fig. 3.6 – Une architecture uniformément bien connectée
Y u2 = Y u1 ⊕ t. On montre que si on restreint les fonctions de décodage aux stratégies sans
mémoire, alors le processus q1 ne peut plus retrouver la valeur de u2 :
Soit Φ = f t un routage, avec f t fonction sans mémoire, et soient (gu,v )v∈VO ,u∈Vue(v) des
fonctions de décodage satisfaisant l’égalité (3.7). Remarquons tout d’abord que si s1 s2 s3 ∈
{u ,u }
(S V )3 est une Φ-séquence, alors st3 ne dépend que de s2 1 2 , puisque f t est sans mémoire
et compatible avec son délai. Par ailleurs, f t : S u1 ,u2 → S t ne peut être injective, donc on
{u ,u }
peut trouver une autre Φ-séquence s1 s′2 s′3 ∈ (S V )3 telle que st3 = s′3 t et s2 1 2 6= s′2 {u1 ,u2 } et
{u ,u }
s3 1 2 = s′3 {u1 ,u2 } . Si par exemple su2 2 6= s′ u2 2 , on obtient
u
gu2 ,v1 ((s1 s2 s3 ){u1 ,t} ) = su2 2 6= s′ 2 2 = g{u2 ,v1 } ((s1 s′2 s′3 ){u1 ,t} ).
Donc gu2 ,v1 ne peut pas être sans mémoire.
Cependant, il est intéressant de voir que si une architecture est uniformément bien connectée, les fonctions de décodage n’ont besoin que d’une mémoire finie, ce qui nous permet de
prouver qu’il est décidable de vérifier qu’une architecture possède cette propriété, qu’on va
appeler de connexion uniforme. En effet, il est important de pouvoir décider si une architecture vérifie cette condition car on peut montrer que le fait d’être à information linéairement
préordonnée devient un critère nécessaire et suffisant de décidabilité pour le problème de SSD
synchrone lorsqu’on se restreint aux architectures UWC. De plus, on peut obtenir la décidabilité de toute la classe des architectures UWC si l’on se restreint à certaines spécifications
dites robustes.
Nous commençons par établir la décidabilité et la complexité de tester si une architecture
est UWC, avant d’aborder les résultats obtenus sur cette classe pour la synthèse de systèmes
synchrones.
3.2
Décider la connexion uniforme
On donne dans cette section une procédure permettant de vérifier si une architecture est
UWC. On évalue sa complexité, et on donne une borne inférieure au problème.
76
Chapitre 3. Synthèse de systèmes synchrones
3.2.1
Décidabilité
On montre tout d’abord que, comme annoncé, si une architecture est UWC avec un routage
Φ = (f v )v∈V \(VI ∪VO ) et des fonctions de décodage (gu,v )v∈VO ,u∈Vue(v) , alors les fonctions de
décodage sont en réalité des fonctions à mémoire finie. On dit qu’une fonction f : X ∗ → Y
est à mémoire finie si elle peut être calculée par un automate déterministe avec sortie à
nombre d’états fini. Dans un tel automate, toutes les exécutions sont acceptantes, et on y
associe une fonction donnant une valeur dans Y en fonction de la transition courante de
l’automate. Par la suite, on va noter pour tout v ∈ VO , gv le tuple (gu,v )u∈Vue(v) de fonctions
de décodages associées à v. On observe que, puisque les fonctions de routage sont sans mémoire
et compatibles avec les délais, la valeur d’une variable dans une séquence Φ-compatible n’est
influencée que par un nombre limité de valeurs de variables d’entrée. Ceci est formalisé dans
le lemme suivant.
Afin de définir précisément la fenêtre de valeurs influençant une variable donnée, on introduit des notations supplémentaires. En effet, on ne va pas seulement utiliser la notion de délai
minimal de transmission de u à v – d(u, v)– mais aussi celle de délai maximal de transmission
D(u, v) définie par
D(u, u) = 0
D(u, v) = +∞ si v ∈
/ (E 2 )+ (u)
D(u, v) = dv + max{D(u, w) | w ∈ R(v) et w ∈ (E 2 )∗ (u)} pour tout u 6= v ∈ (E 2 )+ (u).
On rappelle que pour un mot σ = s1 s2 · · · ∈ Σ∞ , pour tous i, j entiers, on note σ[i · · · j] le
facteur formé des lettres si · · · sj , qui est vide si i > j. On utilise aussi cette notation si i ≤ 0
ou j ≤ 0 : si j ≤ 0, alors σ[i · · · j] = ε, et si i ≤ 0 < j alors σ[i · · · j] = σ[1 · · · j].
Lemme 3.20. Pour tout v ∈ V \ VO , pour tout routage Φ et toute séquence Φ-compatible
σ = s1 · · · si ∈ (S V )+ , la valeur svi ne dépend que de (σ u [i − D(u, v) · · · i − d(u, v)])u∈Vue(v) .
Démonstration.
On rappelle que l’architecture est acyclique. On va donc procéder par
induction sur les variables : les variables minimales sont les variables modifiées par l’environnement (VI ). Soit donc v ∈ VI . Alors Vue(v) = {v}, D(v, v) = d(v, v) = 0 et trivialement,
svi ne dépend que de svi (les variables de VI étant modifiées de façon incontrôlable, elles ne
dépendent que d’elles mêmes). Supposons à présent que v ∈ V \ (VI ∪ VO ). La séquence σ
étant Φ-compatible, svi = f v (σ R(v) ). Les fonctions de routage étant sans mémoire, f v (σ R(v) )
R(v)
sw
ne dépend que de si−dv . Soit w ∈ R(v). Par hypothèse de récurrence,
i−dv ne dépend que de
S
u
(σ [i − dv − D(u, w) · · · i − dv − d(u, w)])u∈Vue(w) . De plus Vue(v) = w∈R(v) Vue(w). Donc, en
utilisant les définitions de délais minimaux et maximaux de transmission, d et D, on déduit
que svi ne dépend que de (σ u [i − D(u, v) · · · i − d(u, v)])u∈Vue(v) .
Notation 3.21. Pour tout v ∈ VO et pour toute séquence Φ-compatible finie σ = s1 · · · s|σ| ∈
(S V \VO )∗ , on définit
Ψv (σ) = σ u [|σ| + 1 − D(u, v) + dv · · · |σ| − d(u, v) + dv ] u∈Vue(v) ,
Ψv (σ) = σ u [1 · · · |σ| − d(u, v) + dv ] u∈Vue(v) .
77
3. Architectures uniformément bien connectées
σ
s
R(v)
Vue(v)
sR(v)
Ψv (σ)
gv ((σ · s)R(v) )
Fig. 3.7 – Valeurs à mémoriser pour décoder sVue(v)
La proposition suivante montre que, pour tout v ∈ VO , Ψv (σ) contient toute l’information
nécessaire pour décoder les valeurs des variables dans Vue(v).
On fixe une variable de sortie v ∈ VO .
Proposition 3.22. Soient σ · s et σ ′ · s′ deux séquences Φ-compatibles telles que σ, σ ′ ∈
(S V \VO )∗ et s, s′ ∈ S V \VO vérifient Ψv (σ) = Ψv (σ ′ ) et sR(v) = s′R(v) . Alors gv ((σ · s)R(v) ) =
gv ((σ ′ · s′ )R(v) ) et Ψv (σ · s) = Ψv (σ ′ · s′ ).
Démonstration.
On écrit σ · s = s1 · · · s|σ| s|σ|+1 et σ ′ · s′ = s′1 · · · s′|σ′ | s′|σ′ |+1 . Il est clair
′
′
que σ · s et σ · s ne sont pas nécessairement de la même longueur. On a donc en général
(σ · s)R(v) 6= (σ ′ · s′ )R(v) . On va donc construire une autre séquence Φ-compatible, σ ′′ · s′′ telle
que, d’une part, (σ · s)R(v) = (σ ′′ · s′′ )R(v) et, d’autre part, gv ((σ ′ · s′ )R(v) ) = gv ((σ ′′ · s′′ )R(v) ).
Cette séquence σ ′′ · s′′ est telle que, pour tout u ∈ Vue(v),
σ ′′u = σ u [1 · · · |σ| − d(u, v) + dv ] · σ ′u [|σ ′ | + 1 − d(u, v) + dv · · · |σ ′ |]
et s′′u = s′u . On fixe arbitrairement les valeurs des variables d’entrée qui ne sont pas dans
la vue de v. On affirme qu’une telle séquence vérifie (σ ′′ · s′′ )R(v) = (σ · s)R(v) . Avant de le
démontrer formellement, on montre comment cette égalité permet de prouver la proposition.
Comme σ ′ · s′ et σ ′′ · s′′ sont deux séquences Φ-compatibles, pour chaque u ∈ Vue(v), on a
gu,v ((σ ′ · s′ )R(v) ) = s′u
|σ′ |+1−d(u,v)+dv
gu,v ((σ ′′ · s′′ )R(v) ) = s′′u
|σ′′ |+1−d(u,v)+dv
′u
et, par définition de σ ′′ , s′′u
|σ′′ |+1−d(u,v)+dv = s|σ′ |+1−d(u,v)+dv . En utilisant l’affirmation faite ci-
dessus que (σ ′′ ·s′′ )R(v) = (σ ·s)R(v) , on en déduit que gu,v ((σ ′ ·s′ )R(v) ) = gu,v ((σ ·s)R(v) ). Donc,
on a bien gv ((σ · s)R(v) ) = gv ((σ ′ · s′ )R(v) ). En utilisant de plus le fait que Ψv (σ) = Ψv (σ ′ ), on
obtient que Ψv (σ · s) = Ψv (σ ′ · s′ ), ce qui prouve la proposition.
On démontre à présent que (σ ′′ · s′′ )R(v) = (σ · s)R(v) . Observons en premier lieu que
′′
|σ | = |σ|. Par définition de σ ′′ , on a Ψv (σ ′′ ) = Ψv (σ). Soit w ∈ R(v) et i ≤ |σ| = |σ ′′ |. Pour
tout u ∈ Vue(w) ⊆ Vue(v), on a i − d(u, w) ≤ |σ| − d(u, v) + dv . En utilisant le lemme 3.20,
w
′′R(v) = σ R(v) .
et le fait que Ψv (σ ′′ ) = Ψv (σ), on déduit que s′′ w
i = si . Ainsi, σ
Il reste à montrer que s′′ R(v) = sR(v) . En utilisant l’égalité Ψv (σ) = Ψv (σ ′ ) et la définition
de σ ′′ · s′′ , on obtient, pour chaque u ∈ Vue(v),
(σ ′′ · s′′ )u [|σ ′′ · s′′ | − D(u, v) + dv · · · |σ ′′ · s′′ | − d(u, v) + dv ]
= (σ ′ · s′ )u [|σ ′ · s′ | − D(u, v) + dv · · · |σ ′ · s′ | − d(u, v) + dv ].
78
Chapitre 3. Synthèse de systèmes synchrones
Soit w ∈ R(v). Pour tout u ∈ Vue(w), on a D(u, w) ≤ D(u, v)−dv et d(u, w) ≥ d(u, v)−dv .
En utilisant le lemme 3.20, on en déduit que s′′ w = s′w . Ceci étant vrai pour tout w ∈ R(v),
s′′ R(v) = s′R(v) . En utilisant l’hypothèse que s′ R(v) = sR(v) , on obtient que s′′ R(v) = sR(v) , ce
qui conclut la démonstration.
On définit maintenant un automate déterministe avec sortie Bv = (Qv , q0v , S R(v) , δv , αv )
qui calcule gv avec une mémoire finie :
– Qv = {ψv (σ) | σ est une séquence finie Φ-compatible}, l’ensemble fini d’états, avec q0v =
Ψv (ε) l’état initial.
– S R(v) l’alphabet d’entrée.
– δv : Qv × S R(v) → Qv est la fonction de transition définie par
(
Ψv (σ · s) si σ · s est une séquence Φ-compatible
R(v)
δv (Ψv (σ), s
)=
indéfinie sinon.
Par la proposition 3.22, δv est correctement définie. On peut déduire immédiatement
par récurrence que δv (q0v , σ R(v) ) = Ψv (σ) pour tout σ, séquence finie Φ-compatible.
– αv : Qv × S R(v) → S Vue(v) est la fonction de sortie définie par
(
gv ((σ · s)R(v) ) si σ · s est une séquence Φ-compatible
αv (Ψv (σ), sR(v) ) =
0
sinon.
Par la proposition 3.22, α est également bien définie. Pour toute séquence Φ-compatible
σ · s, on a
gv ((σ · s)R(v) ) = αv (Ψv (σ), sR(v) ) = αv (δv (q0v , σ R(v) ), sR(v) ).
L’automate fini déterministe Bv calcule donc bien gv .
Remarque 3.23. Si l’architecture est sans délai, alors Qv est un singleton et gv est sans mémoire.
Par la suite, on va noter D = max{D(u, v) − dv | v ∈ VO , u ∈ Vue(v)} et on va fixer un
routage Φ = (f v )v∈V \(VI ∪VO ) .
Notation 3.24. Pour toute séquence Φ-compatible finie σ ∈ (S V \VO )∗ , on note Suff Φ (σ) la
séquence Φ-compatible de longueur D induite par ρ = σ VI [|σ| + 1 − D · · · |σ|] ∈ (S VI )D .
Remarque 3.25. L’automate Bv vérifie δv (q0v , σ R(v) ) = δv (q0v , (Suff Φ (σ))R(v) ) pour toute séquence Φ-compatible finie. En effet, comme, par définition, Ψv (σ) = Ψv (Suff Φ (σ)), alors
δv (q0v , σ R(v) ) = Ψv (σ) = Ψv (Suff Φ (σ)) = δv (q0v , (Suff Φ (σ))R(v) ).
Pour prouver qu’il est décidable de vérifier qu’un automate avec sortie calcule bien la
fonction de décodage recherchée, on doit d’abord montrer les résultats intermédiaires suivants,
assurant qu’on peut vérifier les propriétés recherchées en temps fini.
Lemme 3.26. Soit C = (Q, q0 , S R(v) , δ, α) un automate fini avec sortie, et considérons la
propriété P (σ) sur les séquences Φ-compatibles finies σ ∈ (S V \VO )∗ définie par
δ(q0 , σ R(v) ) = δ(q0 , (Suff Φ (σ))R(v) )
P (σ)
Alors P (σ) est vraie pour toute séquence Φ-compatible finie, si et seulement si P (σ) est vraie
pour toute séquence Φ-compatible de longueur D + 1.
79
3. Architectures uniformément bien connectées
Démonstration.
Supposons que P (σ) soit vraie pour toute séquence Φ-compatible de
longueur D + 1. Soit σ une séquence Φ-compatible arbitraire. On montre que P (σ) est vraie
par récurrence sur la longueur de σ. Si |σ| ≤ D, alors Suff Φ (σ) = σ et P (σ) est vraie.
Supposons à présent que |σ| = k + 1 avec k ≥ D. On écrit σ = s1 · · · sk+1 avec si ∈ S V \VO .
On sait que
R(v)
δ(q0 , σ R(v) ) = δ(δ(q0 , σ[k]R(v) ), sk+1 )
R(v)
= δ(δ(q0 , Suff Φ (σ[k])R(v) ), sk+1 ) par hypothèse de récurrence
= δ(q0 , (Suff Φ (σ[k]) · sk+1 )R(v) ).
Considérons maintenant σ ′ = s′1 · · · s′D+1 ∈ (S V \VO )D+1 la séquence Φ-compatible telle
que σ ′ VI = σ VI [|σ| − D . . . |σ|]. On déduit de la notation 3.24 que Suff Φ (σ[k]) = σ ′ [D]. De plus,
pour w ∈ R(v) et u ∈ Vue(v), on sait que D(u, w) ≤ D(u, v) − dv ≤ D, et le lemme 3.20
R(v)
R(v)
implique que s′ D+1 = sk+1 . Ainsi, (Suff Φ (σ[k]) · sk+1 )R(v) = σ ′ R(v) . Comme |σ ′ | = D + 1,
alors P (σ ′ ) est vraie, ce qui implique que
δ(q0 , (Suff Φ (σ[k]) · sk+1 )R(v) ) = δ(q0 , σ ′R(v) ) = δ(q0 , Suff Φ (σ ′ )R(v) ).
En observant que Suff Φ (σ ′ ) = Suff Φ (σ), on obtient bien P (σ).
Le lemme suivant montre que l’on peut vérifier en temps fini qu’un automate avec sortie
calcule la fonction de décodage correcte.
Lemme 3.27. Soit C = (Q, q0 , S R(v) , δ, α) un automate fini avec sortie tel que P (σ) est
vraie pour toute séquence Φ-compatible finie. Considérons la propriété P ′ (σ) des séquences
Φ-compatibles finies σ = s1 · · · sk+1 ∈ (S V \VO )∗ définie par
R(v)
α(δ(q0 , σ R(v) [k]), sk+1 ) = (suk+1−d(u,v)+dv )u∈Vue(v)
P ′ (σ)
avec la convention sui = 0, pour i ≤ 0.
Alors P ′ (σ) est vraie pour toutes les séquences Φ-compatibles finies si et seulement si
P ′ (σ) est vraie pour toutes les séquences Φ-compatibles de taille inférieure ou égale à D + 1.
Démonstration.
Supposons P ′ (σ) vraie pour toute séquence Φ-compatible de taille inférieure ou égale à D + 1. Soit σ = s1 · · · sk+1 ∈ (S V \VO )∗ une séquence Φ-compatible avec
k > D. Comme P (σ[k]) est vraie, on obtient
R(v)
R(v)
α(δ(q0 , σ R(v) [k]), sk+1 ) = α(δ(q0 , Suff Φ (σ[k])R(v) ), sk+1 ).
Comme dans la preuve du lemme 3.26, on pose σ ′ = s′1 · · · s′D+1 ∈ (S V \VO )D+1 comme
R(v)
′R(v)
étant la séquence Φ-compatible telle que σ ′ VI = σ VI [|σ| − D · · · |σ|]. On a vu que sk+1 = sD+1
et Suff Φ (σ[k]) = σ ′ [D]. Donc
R(v)
′R(v)
α(δ(q0 , Suff Φ (σ[k])R(v) ), sk+1 ) = α(δ(q0 , σ ′ [D]), sD+1 ).
Comme |σ ′ | = D + 1, on sait que P ′ (σ ′ ) est vraie et on obtient que
′R(v)
α(δ(q0 , σ ′ [D]), sD+1 ) = (s′u
D+1−d(u,v)+dv )u∈Vue(v) .
De plus, par définition de σ ′ , on a pour tout u ∈ Vue(v), s′ uD+1−d(u,v)+dv = suk+1−d(u,v)+dv .
On en conclut que P ′ (σ) est vraie.
80
Chapitre 3. Synthèse de systèmes synchrones
3.2.2
Complexité
On démontre à présent que vérifier qu’une architecture est UWC est décidable et on établit
la complexité de la procédure.
Proposition 3.28. Le problème de vérifier si une architecture donnée est UWC est décidable.
De plus, ce problème est
1. dans NP si on se restreint aux architectures
– sans délai,
– pour lesquelles le domaine des variables est borné : |S v | ≤ cs , pour tout v ∈ V , où cs
est une constante indépendante des données du problème,
– pour lesquelles le nombre de variables lues par un processus est borné : |R(v)| ≤ cr ,
pour tout v ∈ V , où cr est une constante indépendante des données du problème.
2. dans NEXPTIME si les délais sont bornés par une constante, i.e., dv ≤ cd pour tout
v ∈ V \ VI , où cd est une constante qui ne dépend pas des données du problème.
3. dans 2-NEXPTIME si on ne pose pas d’hypothèse sur l’architecture donnée
Démonstration.
Considérons une architecture A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ).
Pour vérifier si elle est UWC, on suit la procédure non-déterministe suivante :
– Deviner un routage Φ = (f v )v∈V \(VI ∪VO ) .
– Pour chaque variable de sortie v ∈ VO , deviner un automate déterministe avec sortie
C = (Q, q0 , S R(v) , δ, α) tel que
|Q| ≤ Πu∈Vue(v) |S u |D(u,v)−d(u,v)
et, pour toute séquence ρ ∈ (S VI )+ de longueur D +1, calculer la séquence Φ-compatible
σ ∈ (S V \VO )+ telle que σ VI = ρ et vérifier que P (σ) est vraie et que P ′ (σ[k + 1]) est
vraie pour tout k ≤ D.
En effet, si l’architecture est UWC par le routage Φ et le n-uplet de fonctions de décodage
(gu,v )v∈VO ,u∈Vue(v) , alors pour chaque variable de sortie v ∈ VO l’automate Bv défini après
la proposition 3.22 satisfait les conditions ci-dessus, puisqu’il calcule les fonctions gv et que,
d’après la remarque 3.25, il vérifie P (σ) pour toute séquence Φ-compatible.
Réciproquement, si l’on peut trouver un routage Φ et un automate C pour chaque variable
de sortie v ∈ VO qui satisfait les conditions ci-dessus, alors par le lemme 3.27, on déduit que
la fonction calculée par C satisfait bien l’égalité (3.7). L’architecture est donc bien UWC.
On étudie à présent la complexité de cette procédure de décision. Calculons tout d’abord
la taille nécessaire à la mémorisation d’un routage Φ et d’un automate C. Pour chaque variable
v ∈ V \ (VI ∪ VO ), écrire une fonction sans mémoire f v : S R(v) → S v nécessite une taille de
|S R(v) | · log2 |S v |. Donc,
X
|Φ| ≤
|S R(v) | · log2 |S v |.
v∈V \(VI ∪VO )
On remarque que, étant donnés Φ et ρ ∈ (S VI )+ , on peut calculer la séquence Φ-compatible
induite σ ∈ (S V \VO )+ (c’est-à-dire vérifiant σ VI = ρ), ainsi que Suff Φ (σ) en temps polynomial
par rapport à |Φ| + |ρ|.
Par ailleurs, pour chaque variable de sortie v ∈ VO , et pour chaque u ∈ Vue(v), on a
D(u, v) − d(u, v) ≤ D(u, v) − dv ≤ D. Ainsi, la taille de l’automate déterministe C est donnée
81
3. Architectures uniformément bien connectées
par |C| = |δ| + |α| où
|Q| ≤
Y
|S u |D = |S Vue(v) |D
u∈Vue(v)
|δ| ≤ |Q| · |S R(v) | · log2 |Q|
|α| ≤ |Q| · |S R(v) | · log2 |S Vue(v) |
Étant donnés C, une séquence σ Φ-compatible et Suff Φ (σ), on peut vérifier si P (σ) et P ′ (σ)
sont vraies en temps polynomial par rapport à |C| + |σ|.
Si on considère que le nombre de variables et de processus, la taille de chaque domaine S v
et la valeur de chaque délai dp est donnée en binaire, la taille de l’architecture est donnée par
X
X
|A| = log2 |V | + log2 |P | + |E| +
log2 |S v | +
log2 (1 + dp ).
v∈V
p∈P
On peut à présent se tourner vers les trois cas de la proposition 3.28 :
1. Dans ce cas, on a Φ| ≤ |V | · ccsr · log2 (cs ) = O(|A|), puisque |V | ≤ |E| ≤ |A|. De plus,
D = 0 et |Q| = 1, donc il reste uniquement à deviner la fonction de décodage α telle que
|α| = ccsr · cr · log2 (cs ), qui est constante. Enfin, les seules séquences d’entrée ρ ∈ (S VI )+
que l’on doit considérer sont celles de taille 1. On en déduit que notre algorithme nondéterministe fonctionne en temps polynomial.
2. Ici, l’hypothèse implique que D = O(|V |) = O(A). De plus, comme log2 |S v | ≤ |A| pour
tout v ∈ V , alors pour chaque sous-ensemble des variables U ⊆ V , on a |S U | ≤ 2|U |·|A| .
2
2
En utilisant le fait que |V | ≤ |E| ≤ |A|, on déduit que |S U | ≤ 2|A| . De là, |Φ| = 2O(|A| )
3
3
et |Q| = 2O(|A| ) , et enfin |C| = |δ| + |α| = 2O(|A| ) . De plus, le nombre de séquences
3
d’entrée ρ ∈ (S VI )D+1 à considérer dans notre algorithme est également dans 2O(|A| ) .
On en déduit que notre algorithme non-déterministe fonctionne en temps exponentiel.
3. Dans ce dernier cas, on peut seulement borner D par 2|A| et on obtient que notre
algorithme non-déterministe fonctionne en temps doublement exponentiel.
On détermine à présent une borne inférieure pour la complexité de ce problème. Pour cela,
on établit tout d’abord un lien avec le problème de flux d’information dans un réseau (network
information flow) introduit dans [ACLY00]. Les instances de ce problème sont des graphes
acycliques orientés dans lesquels deux sous-ensembles des nœuds ont été distingués : les sources
et les puits. On se donne en plus d’un tel graphe un certain nombre de messages, et chaque
puits demande un sous-ensemble de ces messages. Formellement, une instance du problème de
flux d’information dans un réseau est un quintuplet (P, M, E, S, demande) dans lequel P est
l’ensemble des processus, M est l’ensemble des messages, la relation E ⊆ (P × P ) ∪ (M × P )
définit l’ensemble des arcs du graphe et l’ensemble V = E ∩ (P × P ) correpond aux variables
internes du réseau (données donc de façon implicite). Toutes les variables de M ∪ V ont le
même domaine S. On dit qu’un processus est une source s’il est relié à un message d’entrée
– l’ensemble des sources du réseau est donc E(M ). Enfin, la fonction demande : P → 2M
définit quels messages doivent être transmis à quels processus, On dit donc qu’un processus
p ∈ P est un puits si demande(p) 6= ∅.
Un problème spécifique a été particulièrement étudié dans ce domaine ; il s’agit du problème de multicast, dans lequel la donnée est une instance du problème défini ci-dessus, ayant
82
Chapitre 3. Synthèse de systèmes synchrones
M1
M2
M3
s
M1
M2
M3
s1
s2
p1
s
s3
p2
s6 s5
p3
s7 s8
p1
p2
p3
s4
p4
p5
p6
p4
p5
p6
y4
y5
y6
s9
Fig. 3.8 – Une instance de multicast et l’architecture distribuée correspondante
une unique source, et dans laquelle tous les puits demandent tous les messages (un exemple
est représenté dans la figure 3.8 dans laquelle les puits sont les processus p4 , p5 et p6 ).
Il est clair que les réseaux que l’on vient de décrire sont très proches des architectures
que l’on considère ici. Les différences résident principalement dans les aspects suivants. Tout
d’abord, une variable d’un réseau est attachée à un arc, ce qui implique qu’une variable ne
peut être lue que par un seul processus quand dans notre cas plusieurs processus peuvent lire
la même variable. Ensuite, le domaine des variables est uniforme pour toutes les variables
d’un réseau dans le problème de flux d’information alors qu’on autorise des domaines de
tailles différentes pour les variables de nos architectures. Enfin, les messages transmis dans
les problèmes de flux d’information dans un réseau le sont sans délai, alors qu’on autorise des
délais arbitraires pour les processus. Donc, les architectures considérées dans le problème de
synthèse que l’on étudie sont plus générales, et on obtient le résultat suivant :
Lemme 3.29. Le problème du multicast se réduit en temps polynomial au problème de connexion uniforme.
Démonstration.
Soit A = (P, M, E, S, demande) une instance du problème du multicast.
Il existe un processus p0 ∈ P , unique source du réseau, et vérifiant donc {p0 } = E(M ). On
définit une architecture A = (Proc′ , V ′ , E ′ , (S v )v∈V ′ , s0 , (dp )p∈Proc′ ) par
Proc′ = P
V ′ = VI ′ ⊎ VO ′ ⊎ V avec
VI ′ = M et
VO ′ = {sp | p ∈ P et demande(p) = M }
E ′ = M × {p0 } ∪ {(p, sp ) | demande(p) = M } ∪
[
v=(p,q)∈V
S v = S pour tout v ∈ V ′ ,
s0 = (0)v∈V ′
dp = 0 pour tout p ∈ Proc′ .
{(p, v), (v, q)}
3. Architectures uniformément bien connectées
83
Une solution au problème de flux d’information dans un réseau est un tuple de fonctions
−1
(f p,q )(p,q)∈E telles que f p,q : S E (p) → S et des fonctions de décodage (gp )p∈demande−1 (M )
−1
telles que gp : S E (p) → S M . Si on pose V = E ∩ (P × P ), une lettre s ∈ S V ∪M est
compatible avec le routage (f p,q )(p,q)∈E si pour tout (p, q) ∈ V , sp,q = f p,q (sR(p,q) ) où R(p, q) =
{(p′ , p) | (p′ , p) ∈ E}. Pour toute lettre s ∈ S V ∪M , compatible avec (f v )v∈V , on veut que
−1
gp (sE (p) ) = sM .
Pour tout v ∈ VO ′ , Vue(v) = VI ′ = M , et pour toute variable interne v ∈ V , R′ (v) = R(v).
Donc la notion de routage sur A correpond à la notion de routage sur A′ .
Par ailleurs, on a vu dans la section 3.2.1 que, s’il existe des fonctions de décodage pour
un routage Φ sur A′ , alors ces fonctions ont une mémoire finie. On a aussi démontré que, pour
v ∈ VO ′ , la mémoire Qv = {Ψv (σ) | σ est une séquence Φ-compatible} est suffisante pour les
fonctions de décodage gv = (gu,v )u∈Vue(v) . Mais, quand tous les délais valent 0, |Qv | = 1, ce
qui signifie que les fonctions gv sont sans mémoire. Ainsi, on peut réécrire la condition (3.7)
Vue(v)
R(v)
= gv (si ), et la notion de fonction de décodage pour A,
de la définition 3.18 en si
fonctions sans mémoire par définition, coı̈ncide avec la notion de fonction de décodage pour
A′ .
Ceci nous permet de conclure que le problème de multicast pour A coı̈ncide avec le problème de connexion uniforme pour A′ .
Rasala Lehman et Lehman [RLL04] ont montré que le problème de multicast dans le cas
où la taille de S est q = pk avec p nombre premier, est NP-dur. Par le lemme 3.29, on obtient :
Corollaire 3.30. Le problème de connexion uniforme est NP-dur.
En fait, on déduit de [RLL04] que le problème du multicast restreint au cas où la taille
de l’alphabet est fixée et égale à 2, le degré entrant est fixé et tel que E −1 (v) ≤ 2 pour tout
nœud v du graphe, est aussi NP-dur. En utilisant les mêmes arguments que dans la preuve
du lemme 3.29, on obtient donc
Corollaire 3.31. Le problème de connexion uniforme pour une architecture telle que :
– le délai dp = 0 pour tout processus p,
– la taille du domaine des variables est fixée, i.e., |S v | ≤ cs pour toutes les variables v,
avec cs une constante qui ne dépend pas de la donnée du problème,
– le degré de lecture est fixé, i.e., |R(v)| ≤ cr pour toutes les variables v ∈ V \ (VI ∪ VO ),
avec cr ≥ 2 une constante qui ne dépend pas de la donnée du problème
est NP-complet.
3.3
Le problème de SSD synchrone pour les architectures UWC
On prouve à présent que le problème de SSD synchrone est décidable pour (A, ϕ), avec A
architecture UWC et ϕ spécification externe, si et seulement si A est à information linéairement préordonnée.
Nous allons commencer par montrer qu’il est en quelque sorte plus facile de trouver des
programmes distribués sur une architecture UWC. En effet, le routage calculé pour transmettre les valeurs des entrées vers les sorties peut être vu comme une collection de stratégies
locales pour les variables internes du système. Ainsi, pour définir une stratégie distribuée, il
suffit de définir un tuple de stratégies reliant les variables de sortie aux variables d’entrée,
compatibles avec les délais des processus de l’architecture.
84
Chapitre 3. Synthèse de systèmes synchrones
Lemme 3.32. Soit A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) une architecture UWC. Pour
chaque variable v ∈ VO , soit hv : (S Vue(v) )+ → S v une application compatible avec les délais.
Alors il existe un programme distribué F = (f v )v∈V \VI pour l’architecture A tel que hv = fˆv
pour tout v ∈ VO .
Démonstration.
Soient Φ = (f v )v∈V \VI ∪VO et (gu,v )v∈VO ,u∈Vue(v) respectivement un routage et les fonctions de décodage permettant de vérifier l’égalité (3.7) de la définition 3.18.
Comme annoncé, on utilise les fonctions de routage f v comme stratégies sans mémoire pour
les variables v ∈ V \ (VI ∪ VO ). Il reste à définir f v pour v ∈ VO . Soit ρ ∈ (S VI )i pour i > 0
et soit σ ∈ (S V \VO )i la séquence Φ-compatible correspondante. Pour v ∈ VO , on va définir f v
par f v (σ R(v) ) = hv (ρVue(v) ). Montrons que de cette façon, la stratégie est bien définie.
Soient i > 0 et ρ, ρ′ ∈ (S VI )i . Soient σ, σ ′ ∈ (S V \VO )i les séquences Φ-compatibles correspondantes, et supposons que σ R(v) [i − dv ] = σ ′R(v) [i − dv ]. Alors, pour tout u ∈ Vue(v),
ρu [i − d(u, v)] = ρ′u [i − d(u, v)]. En effet, pour tout 0 ≤ j ≤ i − d(u, v), l’égalité (3.7) assure
que suj = gu,v (σ R(v) [j + d(u, v) − dv ]) et s′ uj = gu,v (σ ′ R(v) [j + d(u, v) − dv ]). En utilisant le fait
que σ R(v) [i − dv ] = σ ′ R(v) [i − dv ] et j + d(u, v) ≤ i, on obtient bien suj = s′ uj . Comme hv est
d-compatible, on en déduit que hv (ρVue(v) ) = hv (ρ′ Vue(v) ) et f v est donc bien définie.
Ainsi, pour τ ∈ (S R(v) )i avec i > 0, on pose
v
f (τ ) =

v Vue(v) )

h (σ


0
s’il existe σ une séquence Φ-compatible telle que
τ [i − dv ] = σ R(v) [i − dv ]
sinon.
On a montré que f v était bien définie et elle est de plus d-compatible (il est facile de voir
qu’elle ne dépend que de τ [i − dv ]). Soit ρ ∈ (S VI )+ et soit σ l’exécution respectant F induite
par ρ. Par définition des résumés (donnée page 63), on obtient que fˆv (ρVue(v) ) = f v (σ R(v) ).
Comme σ V \VO est aussi une séquence Φ-compatible pour ρ, on obtient, par définition de f v ,
fˆv (ρVue(v) ) = f v (σ R(v) ) = hv (σ Vue(v) ).
On donne maintenant un critère de décidabilité du problème de SSD synchrone pour cette
sous-classe particulière d’architectures.
Théorème 3.33. Le problème de SSD synchrone est décidable pour les instances (A, ϕ) où
A est une architecture UWC et ϕ une spécification externe (linéaire ou branchante) si et
seulement si A est à information linéairement pré-ordonnée.
On a vu dans la proposition 3.14 qu’une architecture à information incomparable est
indécidable pour les spécifications externes de LTL et CTL. On prouve à présent que, pour la
sous-classe des architectures UWC, c’est une condition nécessaire d’indécidabilité.
On fixe jusqu’à la fin de la section une architecture A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc )
qu’on suppose UWC et à information linéairement préordonnée. On va ordonner les variables
de sortie VO = {v1 , . . . , vn } de façon à ce que Vue(vn ) ⊆ · · · ⊆ Vue(v1 ) ⊆ VI .
Pour prouver le théorème, nous allons utiliser des automates d’arbres. On va donc étendre
une stratégie locale f : (S X )+ → S Y en posant f (ε) = sY0 , et la considérer comme un
(S X , S Y )-arbre complet. Jusqu’à la fin du chapitre, nous ne considérerons que des arbres
complets, que l’on nommera simplement arbres. Pour déterminer s’il existe une stratégie distribuée pour une spécification donnée, on procède en deux temps. Tout d’abord, on construit
3. Architectures uniformément bien connectées
85
un automate acceptant toutes les stratégies calculant les sorties en fonction des entrées qui
satisfont la spécification. On ne se restreint donc tout d’abord pas aux stratégies distribuées,
ni aux stratégies compatibles avec les délais. De plus, on ne considère que des stratégies calculant uniquement les valeurs des variables de sortie du système, à l’exclusion des variables
internes. Une telle stratégie est vue comme un (S Vue(v1 ) , S VO )-arbre h vérifiant h(ε) = sV0 O . En
fait, cette première étape revient à faire abstraction des processus internes de A, vus comme
une boı̂te noire, et à ne considérer que des processus « abstraits » lisant les variables d’entrée
et modifiant les variables de sortie. La preuve de ce théorème repose sur le résultat suivant :
Proposition 3.34 ([KV99]). Étant donnée une spécification externe ϕ ∈ CTL∗ (VI ∪ VO ), on
peut construire un automate d’arbre non-déterministe (AAND) A1 sur des (S Vue(v1 ) , S VO )arbres tel que h ∈ L(A1 ) si et seulement si l’arbre des exécutions de h, th : (S VI )∗ → S VI ∪VO ,
satisfait ϕ.
Si L(A1 ) est vide, on peut conclure qu’il n’existe aucune stratégie gagnante pour (A, ϕ).
Vue(v) , S v )Sinon, d’après le lemme 3.32, il reste à vérifier si, pour chaque
L v ∈ VvO , il existe un (S
v
arbre h d-compatible, et tel que la stratégie globale
v∈VO h induite par la collection
(hv )v∈VO est acceptée par A1 . Formellement, si X = X1 ∪ X2 ⊆ VI et Y = Y1 ⊎ Y2 ⊆ VO ,
pour i = 1, 2, on a hi un (S Xi , S Yi )-arbre. Alors h = h1 ⊕ h2 est un (S X , S Y )-arbre tel que
h(σ) = (h1 (σ X1 ), h2 (σ X2 )) pour tout σ ∈ (S X )∗ . La stratégie h est en fait la stratégie distribuée sur l’architecture composée de deux processus, écrivant respectivement sur Y1 et Y2 et
ayant pour variables d’entrée respectivement X1 et X2 .
Pour vérifier l’existence de tels arbres (hv )v∈VO , on va les calculer en considérant les
variables de sortie une par une, en suivant l’ordre v1 , . . . , vn . Il est important de commencer
par la variable ayant la plus large vue des variables d’entrée, même si, de par les délais
éventuels de l’architecture, elle reçoit réellement l’information plus tard que d’autres variables
de sortie.
Pour tout k ≥ 1, on note Vk = {vk , · · · , vn }, et on procède récursivement. Le raisonnement
repose sur la proposition suivante.
Proposition 3.35. Soit 1 ≤ k < n. Soit un AAND Ak acceptant des (S Vue(vk ) , S Vk )-arbres.
On peut construire un AAND Ak+1 acceptant des (S Vue(vk+1 ) , S Vk+1 )-arbres tel qu’un arbre t
est accepté par Ak+1 si et seulement si il existe hvk , (S Vue(vk ) , S vk )-arbre d-compatible tel que
hvk ⊕ t ∈ L(Ak ).
La preuve de la proposition 3.35 se fait en deux étapes. Comme Vk = {vk } ⊎ Vk+1 , tout
t est de la forme t = tvk ⊕ tVk+1 (avec tU la projection de t sur U ). Donc
on peut d’abord transformer l’automate Ak en un automate A′k acceptant les arbres t ∈ L(Ak )
tels que tvk est d-compatible. Ceci est fait dans le lemme 3.36. Ensuite, il reste à construire
un automate qui restreint le domaine des directions ainsi que l’étiquetage des arbres acceptés
par A′k afin d’obtenir des (S Vue(vk+1 ) , S Vk+1 )-arbres.
(S Vue(vk ) , S Vk )-arbre
Lemme 3.36. Soit v ∈ U ⊆ VO et soit un AAND A acceptant des (S Vue(v) , S U )-arbres.
On peut construire un AAND A′ = compatv (A) acceptant des (S Vue(v) , S U )-arbres et tel que
L(A′ ) = {t ∈ L(A) | tv est d-compatible}.
Démonstration.
Dans un arbre compatible avec les délais, certains sous-ensembles de
nœuds doivent être étiquetés de la même façon. Par exemple, l’arbre représenté par la figure 3.9
86
Chapitre 3. Synthèse de systèmes synchrones
(0, 0)
(0, 0)
(0, 1)
(1, 0)
(1, 1)
Fig. 3.9 – Contraintes sur l’étiquetage d’un arbre d-compatible
dans lequel les directions, indiquées entre parenthèses, sont formées par les valeurs de deux
variables, x et y, de délais respectifs d(x, v) = 0, et d(y, v) = 1, est d-compatible si les
deux nœuds encadrés sont étiquetés par la même valeur, et les deux nœuds encerclés sont
également étiquetés par une valeur identique. Intuitivement, pour s’assurer que la fonction
tv est bien d-compatible, l’automate A′ doit deviner à l’avance les valeurs de tv , puis vérifier
que sa prédiction est correcte. Ceci doit être fait K = max{d(u, v), u ∈ Vue(v)} étapes à
l’avance et consiste en une fonction d-compatible g : (S Vue(v) )K → S v qui détermine quelles
devront être les valeurs de la variable v K instants plus tard. Pendant une transition de
l’automate, cette prédiction est envoyée dans chaque direction r ∈ S Vue(v) sous la forme d’une
fonction r −1 g définie par (r −1 g)(σ) = g(rσ), et mémorisée dans l’état de l’automate. Les
prédictions précédentes sont raffinées de façon similaire, et également mémorisée dans l’état
de l’automate. Ainsi l’ensemble des états de A′ est Q′ = Q S
× F, où F est l’ensemble des
fonctions d-compatibles f : (S Vue(v) )<K → S v , avec Z <K = i<K Z i . La valeur f (ε) est la
prédiction ayant été faite K instants plus tôt, et doit être comparée avec la valeur courante
de v dans l’arbre lu. Par exemple, en reprenant l’arbre dessiné figure 3.9, si l’automate est
dans l’état (q, c, δ) en visitant le nœud père, où c ∈ S v est une constante, et δ : S x,y → S v
une fonction d-compatible, si l’étiquette du nœud courant est bien égale à c, l’automate, en
se déplaçant dans la direction (0, 0), va passer dans un état (q ′ , δ(0, 0), δ′ ) où q ′ est dicté par
l’étiquette qu’il a lu, et δ′ est une nouvelle fonction d-compatible correspondant aux valeurs
qu’il s’attend à trouver dans les fils du nœud courant. La fonction δ étant d-compatible, on
s’assure ainsi que δ(0, 0) = δ(0, 1) et l’automate va donc s’assurer ainsi que les nœuds fils dans
les directions (0, 0) et (0, 1) sont bien étiquetés par la même valeur.
Pour formaliser cette intuition, on définit la fonction ∆ : F × S Vue(v) → 2F par
∆(f, r) = {f ′ | f ′ (σ) = f (rσ) pour tout |σ| < K − 1}.
Cette fonction de transition signifie que, lorsque l’automate se trouve dans un état (q, f ) ∈
Q×F à un nœud τ de l’arbre, en allant dans la direction r ∈ S Vue(v) , ∆(f, r) calcule l’ensemble
des fonctions de F qui pourraient étiqueter le nœud τ · r. En fait f ′ est déterminé par f et r
pour toutes les valeurs σ telles que |σ| < K − 1, et correspond alors au raffinement de f par
rapport à la direction r. Les fonctions f ′ ∈ ∆(f, r) diffèrent donc seulement sur les valeurs de
σ telles que |σ| = K − 1 qui correspondent aux nouvelles prédictions.
On définit maintenant la fonction de transition de A′ . Tout d’abord, elle n’est définie
que pour les états (q, f ) ∈ Q′ et s ∈ S U tels que sv = f (ε) – si c’est le cas, cela signifie
que la prédiction faite K instants plus tôt était correcte. Sinon, l’exécution en cours n’est
87
3. Architectures uniformément bien connectées
pas acceptante et peut être stoppée. Lors d’une transition, on envoie dans chaque direction
r ∈ S Vue(v) de l’arbre une copie de l’automate dans l’état (qr , gr ) où qr correspond à la
simulation d’une exécution de A et gr ∈ ∆(f, r). Formellement, si sv = f (ε),
δ (q, f ), s = (qr , gr )r∈S Vue(v) ′
(qr )r∈S Vue(v) ∈ δ(q, s) et
gr ∈ ∆(f, r) pour tout r ∈ S Vue(v)
.
Enfin, l’ensemble des états initiaux de A′ est donné par I ′ = {q0 } × F et α′ = π −1 (α),
où π : (Q × F)ω → Q est la projection sur la composante Q, i.e., une exécution de A′ est
acceptante si et seulement si sa projection sur Q est une exécution acceptante de A.
On montre à présent que l’automate A′ est bien celui demandé par le lemme 3.36.
Soit t un (S Vue(v) , S U )-arbre accepté par A et supposons que tv est d-compatible. Soit
ρ : (S Vue(v) )∗ → Q une exécution acceptante de A sur t. Il y a une façon unique d’étendre ρ en
une exécution ρ′ : (S Vue(v) )∗ → Q × F de A′ sur t. La seule possibilité est d’étiqueter un nœud
σ ∈ (S Vue(v) )∗ par l’application fσ : (S Vue(v) )<K → S v définie pour tout τ ∈ (S Vue(v) )<K par
fσ (τ ) = t(στ )v , afin que les prédictions soient correctes. Comme tv est d-compatible, on en
déduit que fσ est aussi d-compatible, et donc appartient bien à F. On définit donc l’exécution
ρ′ par ρ′ (σ) = (ρ(σ), fσ ) pour σ ∈ (S Vue(v) )∗ . On peut montrer que ρ′ est une exécution
acceptante de A′ sur t. En effet, prouvons d’abord que pour chaque nœud σ ∈ (S Vue(v) )∗ ,
la fonction de transition δ′ est satisfaite. Soient (q, fσ ) = ρ′ (σ) et, pour tout r ∈ S Vue(v) ,
(qr , fσr ) = ρ′ (σr). Par définition, fσ (ε) = tv (σ) et δ′ ((q, fσ ), t(σ)) est définie. Comme πQ (ρ′ ) =
ρ, qui est une exécution de A sur t, on sait que (qr )r∈S Vue(v) ∈ δ(q, t(σ)). Il nous reste à montrer
que fσr ∈ ∆(fσ , r) pour tout r ∈ S Vue(v) . En fait, cela découle directement des définitions :
pour tout τ ∈ (S Vue(v) )<K−1 , fσr (τ ) = tv (σrτ ) = fσ (rτ ). Enfin, l’exécution ρ est acceptante,
puisque sa projection sur Q est ρ qui est une exécution acceptante.
Réciproquement, supposons qu’il existe une exécution acceptante de A′ sur t. On doit
montrer que tv est d-compatible et que t ∈ L(A). On appelle ρ′ : (S Vue(v) )∗ → Q × F une
telle exécution. On décompose ρ′ = (ρ, H) en ρ : (S Vue(v) )∗ → Q et H : (S Vue(v) )∗ → F. Par
définition de δ′ , on obtient immédiatement que ρ est une exécution de A sur t, et qu’elle est
acceptante puisque ρ′ est acceptante.
Montrons que tv est d-compatible. Comme ρ′ est une exécution et que la fonction de
transition δ′ est uniquement définie pour ((q, f ), s) avec sv = f (ε), on déduit que tv (τ ) =
H(τ )(ε) pour tout τ ∈ (S Vue(v) )∗ . On doit donc montrer que l’application τ 7→ H(τ )(ε) est
d-compatible.
Soient τ, τ ′ ∈ (S Vue(v) )i tels que, pour tout u ∈ Vue(v), τ u [i − d(u, v)] = τ ′ u [i − d(u, v)].
On doit alors avoir H(τ )(ε) = H(τ ′ )(ε).
Si |τ | = |τ ′ | > K, alors on montre que nécessairement τ, τ ′ partagent un préfixe commun.
Plus précisément, comme, pour tout u ∈ Vue(v), K ≥ d(u, v), on déduit du fait que τ u [i −
d(u, v)] = τ ′ u [i − d(u, v)] pour tout u ∈ Vue(v) que τ = τ1 τ2 et τ ′ = τ1 τ2′ avec |τ2 | = |τ2′ | = K
et, pour tout u ∈ Vue(v), τ2u [K −d(u, v)] = τ ′ u2 [K −d(u, v)]. On peut montrer, par applications
successives de la fonction de transition δ′ , et par définition de ∆, que la valeur de H(τ1 τ2 )(ε) est
en fait la prédiction faite au nœud τ1 pour la direction définie par τ2 : H(τ1 τ2 )(ε) = H(τ1 )(τ2 ).
De même, on obtient que H(τ1 τ2′ )(ε) = H(τ1 )(τ2′ ). Comme H(τ1 ) ∈ F, c’est une fonction dcompatible. Comme, pour tout u ∈ Vue(v), τ2u [K − d(u, v)] = τ ′ u2 [K − d(u, v)], on déduit que
H(τ1 )(τ2 ) = H(τ1 )(τ2′ ). Donc, H(τ )(ε) = H(τ ′ )(ε).
Si |τ | < K, alors on obtient de façon similaire que, puisque H(ε) ∈ F est d-compatible,
H(τ )(ε) = H(ε)(τ ) = H(ε)(τ ′ ) = H(τ ′ )(ε).
88
Chapitre 3. Synthèse de systèmes synchrones
Démonstration de la proposition 3.35.
Considérons l’AAND compatvk (Ak ). Afin de
conclure la démonstration, on doit supprimer la composante S vk de l’étiquette des arbres
acceptés, et sélectionner les arbres de L(compatvk (Ak )) tels que la composante S Vk+1 de
l’étiquette ne dépend que de la composante S Vue(vk+1 ) de la direction. La première opération est la construction classique de l’automate projection sur S Vk+1 , et la seconde correspond à la construction de rétrécissement (appelée narrow ) introduite dans [KV99]. On
décrit intuitivement cette construction. Soit t : (S Vue(vk+1 ) )∗ → S Vk+1 un arbre. On peut
construire l’arbre wideVue(vk ) (t) : (S Vue(vk ) )∗ → S Vk+1 défini pour tout σ ∈ (S Vue(vk ) )∗ par
wideVue(vk ) (t)(σ) = t(σ Vue(vk+1 ) ). Ainsi, les nœuds de wideVue(vk ) (t) sont étiquetés d’une
façon ne dépendant pas de la composante S Vue(vk )\Vue(vk+1 ) de leur direction. Pour tout
A = (S Vue(vk ) , S Vk+1 , Q, q0 , δ, α) un automate alternant acceptant des arbres t : (S Vue(vk ) )∗ →
S Vk+1 , on note narrowVue(vk+1 ) (A) = (S Vue(vk+1 ) , S Vk+1 , Q, q0 , δ′ , α) l’automate acceptant tous
les arbres t : (S Vue(vk+1 ) )∗ → S Vk+1 tels que wideVue(vk ) (t) ∈ L(A). Pour q ∈ Q et s ∈ S Vk+1 ,
la fonction de transition δ′ (q, s) de l’automate narrowVue(vk+1 ) (A) est définie comme étant la
fonction de transition δ(q, s) de l’automate A dans laquelle on remplace chaque élément de la
forme (r, qr ) avec r ∈ S Vue(vk ) , et qr ∈ Q par l’élément (r Vue(vk+1 ) , qr ). Ainsi, l’arbre d’exécution de narrowVue(vk+1 ) (A) sur un arbre t est l’arbre d’exécution de A sur un arbre t′ dont l’étiquetage ne tient pas compte de la composante S Vue(vk )\Vue(vk+1 ) , et tel que t′ = wideVue(vk ) (t).
On remarque que même si l’automate A est non-déterministe, l’automate narrowVue(vk+1 ) (A)
construit est alternant : dans chaque direction r ∈ S Vue(vk+1 ) de l’arbre, narrowVue(vk+1 ) (A)
envoie au moins une copie de A par direction r ∈ S Vue(vk ) tel que rVue(vk+1 ) = r.
L’automate Ak+1 annoncé par la proposition 3.35 est donc donné par
Ak+1 = narrowVue(vk+1 ) (projVk+1 (compatvk (Ak )))
. Comme on l’a remarqué ci-dessus, bien que l’automate Ak soit un AAND, la construction
narrow décrite dans [KV99] construit un automate d’arbres alternant. L’automate Ak+1 annoncé est donc l’automate narrowVue(vk+1 ) (projVk+1 (compatvk (Ak ))) transformé en AAND, en
utilisant la construction classique de [MS95] (voir le théorème 2.9). L’inconvénient est que
cette transformation induit une augmentation exponentielle de la taille de l’automate. Malheureusement, la construction décrite dans le lemme 3.36 nécessite de prendre un AAND en
entrée.
On conclut à présent la preuve du théorème 3.33. On commence par construire l’automate
A1 de la proposition 3.34, puis on applique récursivement la construction de la proposition 3.35
jusqu’à obtenir un AAND An acceptant un (S Vue(vn ) , S vn )-arbre hvn si et seulement si pour
tout 1 ≤ i ≤ n, il existe un (S Vue(vi ) , S vi )-arbre hvi d-compatible et tel que hv1 ⊕ · · · ⊕ hvn ∈
L(A1 ). Ainsi, par le lemme 3.32, il existe une stratégie distribuée gagnante pour la spécification
sur A si et seulement si compatvn (An ) est non-vide. La complexité de la procédure est nonélémentaire, par application successive de la construction de la proposition 3.35 induisant
chaque fois une augmentation exponentielle de la taille de l’automate. On ne connaı̂t pas
pour le moment de borne inférieure pour la complexité de ce problème.
3.4
Architectures UWC et spécifications robustes
Dans cette section, on montre que si l’on restreint le type de spécifications que l’on s’autorise, on obtient la décidabilité du problème de SSD synchrone pour toute la classe des
architectures UWC.
4. Architectures bien connectées
89
∗
Définition 3.37. Une spécification ϕ ∈ L avec L ∈ {LTL,
V CTL, CTL } est robuste si elle
s’écrit comme une disjonction finie de formules de la forme v∈VO ϕv où ϕv ∈ L(Vue(v)∪{v}).
Remarque 3.38. Une spécification robuste est toujours externe.
Proposition 3.39. Le problème de SSD synchrone est décidable pour les instances (A, ϕ) où
A est une architecture UWC et ϕ une spécification robuste de CTL∗ .
Démonstration.
Soit A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) une architecture UWC.
Soit ϕ une spécification robuste de CTL∗ . Sans perte de généralité, on suppose
V
V que ϕ =
∗
ϕ
,
avec
ϕ
∈
CTL
(Vue(v)
∪
{v}).
En
effet,
considérons
une
formule
ϕ
=
v
v∈VO ϕv ∨
V
V
Vv∈VO v′
′
v∈VO ϕv ,
v∈VO ϕv ou pour
v∈VO ϕv . S’il existe une stratégie distribuée gagnante pour
alors elle est évidemment gagnante pour ϕ. Réciproquement, soit F une stratégie distribuée
V
VI ∗
respectant F , vérifie
gagnante pour (A, ϕ). Alors tF : (S
V ) → S , l’arbreVdes exécutions
′
tF |= ϕ, et par définition, tFV |= v∈VO ϕv ouVtF |= v∈VO ϕv . Donc F est une stratégie
distribuée gagnante pour (A, v∈VO ϕv ) ou (A, v∈VO ϕ′v ).
V
Soit donc ϕ = v∈VO ϕv , avec ϕv ∈ CTL∗ (Vue(v) ∪ {v}). Par la proposition 3.34, on peut
construire, pour chaque v ∈ VO un AAND Av acceptant une stratégie h : (S Vue(v) )∗ → S v si
et seulement si t : (S Vue(v) )∗ → S Vue(v)∪{v} , l’arbre des exécutions respectant h, satisfait ϕv .
On affirme qu’il existe une stratégie distribuée gagnante pour (A, ϕ) si et seulement si, pour
chaque v ∈ VO , l’automate compatv (Av ) est non-vide.
En effet, soit F une stratégie distribuée gagnante pour (A, ϕ) et soit t : (S VI )∗ → S V l’arbre
des exécutions respectant F . Fixons une variable v ∈ VO . L’application fˆv : (S Vue(v) )∗ → S v
est d-compatible. Considérons t′ : (S Vue(v) )∗ → S Vue(v)∪{v} l’arbre des exécutions respectant
fˆv . Alors, pour chaque σ ∈ (S VI )∗ , t(σ)Vue(v)∪{v} = t′ (σ Vue(v) ). Comme F est une stratégie
gagnante, t |= ϕ et donc t |= ϕv . En procédant par récurrence sur la structure de la formule, il
est immédiat que pour toute formule ψ ∈ CTL∗ (Vue(v) ∪ {v}), pour toute branche σ ∈ (S VI )ω ,
et toute position i, on a t, σ, i |= ψ si et seulement si t′ , σ Vue(v) , i |= ψ. On en déduit, puisque
ϕv ∈ CTL∗ (Vue(v) ∪ {v}), que t′ |= ϕv . Ainsi, fˆv ∈ L(Av ) et donc fˆv ∈ L(compatv (Av )).
Réciproquement, pour tout v ∈ VO , soit hv : (S Vue(v) )∗ → S v une stratégie acceptée par
compatv (Av ). D’après le lemme 3.36, hv est d-compatible. Soit tv : (S Vue(v) )∗ → S Vue(v)∪{v}
l’arbre des exécutions respectant hv . Par définition de Av , tv |= ϕv . D’autre part, par le
lemme 3.32, il existe une stratégie distribuée F = (f v )v∈V \VI telle que fˆv = hv pour tout
v ∈ VO . Appelons t : (S VI )∗ → S V l’arbre des exécutions respectant F . Pour tout σ ∈ (S VI )∗ ,
t(σ)Vue(v)∪{v} = tv (σ Vue(v) ) et on obtient comme précédemment que t |= ϕv . Ainsi, t |= ϕ et
F est une stratégie distribuée gagnante pour (A, ϕ).
4
Architectures bien connectées
Une question naturelle est de se demander si le critère de décidabilité que nous venons
d’établir pour les architectures UWC peut être étendu à une classe plus large d’architectures.
Dans cette section nous relâchons légèrement la définition de cette propriété et nous montrons
que malheureusement, dans ce cas, être à information linéairement préordonnée n’est plus une
condition suffisante pour obtenir la décidabilité du problème.
90
Chapitre 3. Synthèse de systèmes synchrones
z12
u
w
z1
z2
z3
z4
z13
z14
z23
z24
z34
Fig. 3.10 – Une architecture bien connectée
4.1
Définition
Définition 3.40. Une architecture est bien connectée si, pour chaque variable de sortie
v ∈ VO , la sous-architecture constituée des variables de (E −1 )∗ (v) est uniformément bien
connectée.
Intuitivement, une architecture est bien connectée si, pour chaque variable de sortie v il y a
un routage permettant de transmettre les valeurs des variables de Vue(v) au processus écrivant
sur v, mais ce routage n’a pas besoin d’être identique pour toutes les variables de sortie,
contrairement à une architecture uniformément bien connectée pour laquelle on demande
l’existence d’un unique routage pour toutes les variables.
Exemple 3.41. L’architecture de la figure 3.10 est bien connectée. En effet, pour transmettre
les valeurs de u et w à zij , il suffit de recopier la valeur de u sur zi et la valeur de w sur zj . On
note que ce routage n’est pas uniforme. En fait, si le domaine des variables est {0, 1}, cette
architecture n’est pas uniformément bien connectée (voir proposition 3.43).
Nous montrons donc tout d’abord que les architectures UWC forment une sous-classe
stricte des architectures bien connectées. Dans la preuve de la proposition 3.43, on utilise le
lemme suivant, établi dans [RLL04] afin de résoudre le problème de transmission d’information
dans un réseau (présenté dans la section 3.2.2).
On dit que deux fonctions f et g de S 2 dans S sont indépendantes si (f, g) : S 2 → S 2 est
bijective.
Lemme 3.42 ([RLL04]). Si f 1 , . . . , f n sont des fonctions de S 2 dans S indépendantes deux
à deux, alors n ≤ |S| + 1.
Ce lemme établit que sur un petit domaine, on ne peut construire un grand ensemble de
fonctions deux à deux indépendantes. Pour nous, il a la conséquence suivante :
Proposition 3.43. L’architecture représentée figure 3.10, dans laquelle S v = {0, 1} pour
tout v ∈ V , et dp = 0 pour tout p ∈ Proc est bien connectée, mais pas uniformément bien
connectée.
Démonstration.
Il est facile de montrer que l’architecture A de la figure 3.10 est bien
connectée (voir l’exemple 3.41). Supposons qu’elle est aussi UWC. Alors il existe un routage
91
4. Architectures bien connectées
u
w
p0
p1
x
q
z0
z1
p2
v
z2
z3
p3
p4
z4
p5
p6
u1 w1 u2 w2 u3 w3 u4 w4 u5 w5 u6 w6
y
Fig. 3.11 – Architecture bien connectée, à information linéairement préordonnée, et indécidable
Φ = (f z1 , f z2 , f z3 , f z4 ) et, pour toute variable de sortie v ∈ VO , des fonctions de décodage
gu,v : {0, 1}2 → {0, 1} et gw,v : {0, 1}2 → {0, 1}. On rappelle que lorsque l’architecture est
sans délai, les fonctions de décodage sont sans mémoire. On notera gv : {0, 1}2 → {0, 1}2 la
fonction qui, à x ∈ {0, 1}2 associe gv (x) = (gu,v (x), gw,v (x)). Comme A est uniformément bien
connectée, chaque paire (f zi , f zj ) est inversible, d’inverse gzij . Or, ceci est en contradiction
avec le lemme 3.42, qui implique que pour des domaines booléens, il y a au plus trois fonctions
indépendantes deux à deux. On en conclut que l’architecture n’est pas uniformément bien
connectée.
En fait, comme nous l’avons informellement remarqué au début de la section 3, la taille
du domaine des variables a une influence sur la possibilité d’avoir un routage uniforme ou
non, et le lemme 3.42 aide à comprendre pourquoi. Pour le problème de synthèse de système
distribué synchrone, cela signifie qu’en augmentant suffisamment le domaine des variables
internes, on peut transformer une architecture bien connectée en architecture uniformément
bien connectée.
4.2
Architecture à information linéairement préordonnée indécidable
Le théorème suivant établit que le critère de décidabilité présenté dans les sections précédentes ne s’étend pas aux architectures bien connectées.
Théorème 3.44. Le problème de SSD synchrone est indécidable pour les instances (A, ϕ) où
A est une architecture bien connectée à information linéairement préordonnée et ϕ est une
spécification externe de LTL.
La fin de la section est dédiée à la démonstration de ce théorème. Soit A l’architecture de
la figure 3.11, dans laquelle tous les délais valent 0. Elle est clairement bien connectée, et à
information linéairement préordonnée : pour toutes les variables ui et wi , 1 ≤ i ≤ 5, on peut
transmettre les valeurs des variables u et w : la valeur de u est copiée sur z0 , puis il existe
i1 , i2 tels que {zi1 , zi2 } = R(ui ) = R(wi ). Il suffit alors de copier z0 et w respectivement sur
zi1 et zi2 . Pour les variables u6 , w6 et y il faut également transmettre la valeur de v qui est
directement dans leur domaine de lecture. De même, on demande de transmettre u à la variable
x, ce qui se fait directement. Par ailleurs, elle est à information linéairement préordonnée :
Vue(x) ⊆ Vue(ui ) = Vue(wi ) pour 1 ≤ i ≤ 5, et Vue(ui ) ⊆ Vue(u6 ) = Vue(w6 ) = Vue(y).
92
Chapitre 3. Synthèse de systèmes synchrones
Pour une machine de Turing M , on définit une spécification LTL ϕM et on va réduire le
problème du non-arrêt de M sur bande vide au problème de synthèse de système distribué
synchrone pour (A, ϕM ). Soit S z = {0, 1} pour z ∈ V \ {x, y} et S x = S y = Γ ⊎ Q ⊎ {#}
avec # un nouveau symbole. Une configuration de M définie par un état q et un contenu
de bande γ1 γ2 , avec la tête de lecture située sur le premier symbole de γ2 est représentée
par le mot γ1 qγ2 ∈ Γ∗ QΓ+ (on demande que γ2 soit non vide pour des raisons techniques,
en ajoutant des symboles vides si nécessaire). Une séquence de valeurs prises par la variable
u ∈ 0∗ 1p 0{0, 1}ω code l’entier n(u) = p. On prend le même codage pour la variable v. On
construit donc une spécification LTL ϕM forçant toute stratégie distribuée gagnante à écrire
sur la variable x la n(u)-ième configuration de M lorsqu’elle commence sur la bande vide.
Ainsi, les processus p0 et p6 vont jouer le rôle des deux processus de l’architecture indécidable
de [PR90] (voir la démonstration du théorème 3.13). Bien sûr, notre cas est différent puisque
le processus p6 a la possibilité matérielle de recevoir de l’information sur la valeur de u. La
difficulté est donc de masquer les informations utiles sur la valeur de u au processus p6 .
4.2.1
Description de la spécification
La spécification que nous allons construire est très proche de celle écrite dans la démonstration du théorème 3.13. On rajoute essentiellement une sous-formule ayant pour but
d’empêcher la transmission d’information au processus p6 . Bien sûr, comme la spécification
est externe, on ne peut pas directement empêcher les processus de communiquer l’information, mais on utilise le fait qu’il est impossible de transmettre les valeurs en entrée de p0 et q
simultanément à tous les processus. Formellement, soit ϕM = α ∧ β ∧ γM ∧ δ ∧ ψM conjonction
des cinq propriétés décrites ci-dessous.
1. Les processus pi , pour 1 ≤ i ≤ 5 doivent copier les valeurs courantes de (u, w) sur
les variables (ui , wi ) jusqu’à ce que w prenne la valeur 1 (valeur incluse). Puis, ils ne
sont plus restreints par la spécification. Le processus p6 doit toujours copier la valeur
courante de w sur w6 . De plus, après l’occurrence du premier 1 sur w, il doit copier
aussi la valeur courante de u sur u6 . Ceci est formalisé par la formule α ∈ LTL(VI ∪ VO )
suivante :
h
i
def
α = G(w6 = w) ∧ (w = 0) ∧ α′ W (w = 1) ∧ α′ ∧ X G(u6 = u) , avec
^
def
(uk = u) ∧ (wk = w)
α′ =
1≤k≤5
2. Si la séquence des valeurs prises par u (respectivement v) est dans 0q 1p 0{0, 1}ω , alors
la séquence des valeurs prises par x (respectivement y) est dans #q+p Γ∗ QΓ+ #ω .
Ceci est exprimé par la formule β = βu,x ∧ βv,y avec
def
βz,t = ((z = 0) ∧ (t = #)) W
∗
+ ω
(z = 1) ∧ ((z = 1) ∧ (t = #)) W ((z = 0) ∧ (t ∈ Γ QΓ # ))
où
def
(t ∈ Γ∗ QΓ+ #ω ) = (t ∈ Γ) U ((t ∈ Q) ∧ X(t ∈ Γ) U ((t ∈ Γ) ∧ X G(t = #)))
93
4. Architectures bien connectées
3. La formule γM que nous décrivons à présent impose que si n(u) = 1, alors la séquence
de valeurs prises par x doit correspondre au codage de C1 , la première configuration de
la machine de Turing M commençant sur bande vide. Plus précisément, si la séquence
de valeurs prises par u est dans 0q 10{0, 1}ω , alors la séquence de valeurs prises par x au
cours de l’exécution est #q+1 C1 #ω . La formule γM ∈ LTL(VI ∪ VO ) est
def
γM = (u = 0) W ((u = 1) ∧ X((u = 0) → (x ∈ C1 #ω )))
où (x ∈ C1 #ω ) peut s’exprimer facilement.
4. On dit que les mots d’entrée sont synchronisés si, soit u, v ∈ 0q 1p 0{0, 1}ω soit u ∈
0q 1p+1 0{0, 1}ω et v ∈ 0q+1 1p 0{0, 1}ω . La formule δ exprime le fait que si u et v sont
synchronisés, et que n(u) = n(v), alors x et y prennent la même séquence de valeurs
au cours de l’exécution. Pour exprimer le fait que u et v sont synchronisés et que
n(u) = n(v), on définit la formule de LTL(VI ∪ VO )
def
(n(u) = n(v)) = (u = v = 0) U ((u = v = 1) ∧ (u = v = 1) U (u = v = 0))
La formule δ est donc définie par
def
δ = (n(u) = n(v)) → G(x = y)
5. Enfin, on exprime avec la formule ψM que si les séquences d’entrée sont synchronisées
et telles que n(u) = n(v) + 1, alors la configuration encodée sur la variable x est la
configuration successeur de la configuration encodée sur la variable y dans l’exécution
de la machine de Turing M . Pour exprimer le fait que n(u) = n(v) + 1 on utilise la
formule (n(u) = n(v) + 1) ∈ LTL(VI ∪ VO ) définie par :
(u = v = 0) U (u = 1) ∧ (v = 0) ∧ X((u = v = 1) ∧ (u = v = 1) U (u = v = 0))
La formule ψM est donc :
ψM = (n(u) = n(v) + 1) → (x = y) U Trans(y, x) ∧ X3 G(x = y)
où Trans(y, x) exprime le fait que le facteur de trois lettres de x est obtenu à partir de
celui de y en effectuant une transition de la machine de Turing M . On a
_
Trans(y, x) =
(y = cpa) ∧ (x = qcb)
(p,a,q,b,←)∈T,c∈Γ
∨
_
(y = pac) ∧ (x = bqc)
(p,a,q,b,→)∈T,c∈Γ
∨
_
(y = pa#) ∧ (x = bq)
(p,a,q,b,→)∈T
On utilise l’abréviation (x = abc) pour (x = a) ∧ X(x = b) ∧ X2 (x = c). De plus, est le symbole vide de la bande et T est l’ensemble des transitions de M (la transition
(p, a, q, b, dir ), prise quand M est dans l’état p avec la tête de lecture sur le symbole a,
change l’état de la machine en q, écrit sur la bande le symbole b et déplace la tête de
lecture dans la direction dir ∈ {←, →}).
94
Chapitre 3. Synthèse de systèmes synchrones
On montre tout d’abord qu’il existe une stratégie distribuée gagnante pour (A, ϕM ).
Comme précédemment, on va noter ⊕ l’addition modulo 2 (ou XOR). Le processus p0 va
copier la valeur de u sur z0 . Le processus q copie z0 (donc la valeur de u) sur z1 , u ⊕ w sur
z2 et w sur z3 . Sa stratégie pour modifier z4 nécessite elle de la mémoire : le processus q va
copier sur z4 la valeur de w jusqu’à ce que w prenne la valeur 1 pour la première fois (valeur
incluse). Puis, il écrit u ⊕ w sur z4 . Formellement, pour tout u ∈ {0, 1}∗ , tout b ∈ {0, 1},
f z4 (u, 0q b) = b et pour tout u, w ∈ {0, 1}∗ , et tout a, b ∈ {0, 1}, f z4 (ua, 0q 1wb) = a ⊕ b. Les
stratégies pour les variables ui , wi , pour 1 ≤ i ≤ 6 sont données par, pour a, b ∈ {0, 1}
f u1 (a, b) = a
f w1 (a, b) = a ⊕ b
f u2 (a, b) = a
f w2 (a, b) = b
f u3 (a, b) = a
f w3 (a, b) = b
f u4 (a, b) = a ⊕ b
f w4 (a, b) = b
f u5 (a, b) = a ⊕ b
f w5 (a, b) = b
f u6 (a, b) = a ⊕ b
f w6 (a, b) = a
Il est facile de se convaincre que toute exécution respectant ces stratégies locales satisfait la
formule α. On remarque que tant que w n’a pas pris la valeur 1, la variable u6 vaut toujours
0, et qu’après cette première occurence de 1 sur w, la variable u5 est toujours mise à 0 (mais
la spécification ne contraint plus le processus p5 à copier les variables u et w).
La stratégie f x (respectivement f y ) est d’écrire la p-ième configuration de M commençant
sur la bande vide lorsque la séquence de valeurs prises par u (respectivement v) code p. On
rappelle qu’avec l’encodage choisi, on peut déterminer quelle configuration est codée après un
temps fini. Ainsi, on est assuré que le reste de la spécification β ∧ γM ∧ δ ∧ ψM est satisfaite.
Remarque 3.45. En fait, on pourrait décrire une autre stratégie gagnante en modifiant la
stratégie de z4 : à chaque instant, le processus q transmet au processus p6 la valeur de u à
l’instant précédent comme étant la différence modulo 2 des valeurs de z3 et z4 , tant que le
premier 1 n’est pas apparu sur w. Formellement, pour tout a, a1 , a2 , b ∈ {0, 1}, pour tout
u, w ∈ {0, 1}∗ , f z4 (a, b) = b, f z4 (u · a1 · a2 , 0q b) = a1 ⊕ b et f z4 (ua, 0q 1wb) = a ⊕ b. On adapte
également les stratégies des processus p3 et p5 afin de satisfaire α : elles ne peuvent plus être
sans mémoire, elles doivent mémoriser la dernière valeur prise par u. Par exemple, le processus
p5 reçoit à l’instant initial les valeurs de w et de u ⊕ w. Il peut donc retrouver u en effectuant
le XOR de ses deux entrées. À l’instant suivant par contre, il reçoit la valeur de w additionnée
de la valeur de u précédente (ce qu’on va noter Y u ⊕ w), ainsi que la valeur courante de u ⊕ w.
Pour décoder w il doit effectuer la somme modulo 2 de Y u ⊕ w avec la valeur précédente de u,
soit avec la somme modulo 2 de ses deux entrées précédentes : f w5 (a1 a2 , b1 b2 ) = a2 ⊕ a1 ⊕ b1 .
À présent, en effectuant la somme modulo 2 de ses deux valeurs en entrée, le processus p6
peut reconstituer toute l’histoire des valeurs prises par u, à l’exception d’une seule, celle écrite
sur u au même instant que le premier 1 sur w. Ceci signifie que nous nous trouvons presque
dans le cas de l’architecture décidable de la figure 2.3, mais que, de façon surprenante, perdre
un bit d’information suffit à entraı̂ner l’indécidabilité.
On prouve à présent que s’il existe une stratégie gagnante F = (f v )v∈V \VI pour (A, ϕM ),
alors nécessairement f x simule le comportement de la machine de Turing M commençant sur
bande vide. La difficulté supplémentaire par rapport au théorème 3.13 réside dans le fait qu’on
doit s’assurer qu’aucune stratégie gagnante ne peut transmettre suffisamment d’information
95
4. Architectures bien connectées
à p6 pour lui permettre de « tricher » et d’écrire sur sa variable de sortie une configuration
différente de celle dictée par u.
4.2.2
Relations entre les stratégies de z3 et z4
Lemme 3.46. Soient g1 , g2 , g3 : {0, 1}2 → {0, 1} des fonctions indépendantes deux à deux.
Alors il existe ε ∈ {0, 1} tel que pour tout a, b ∈ {0, 1} :
g3 (a, b) = ε ⊕ g1 (a, b) ⊕ g2 (a, b)
Démonstration.
On remarque d’abord que chaque fonction gk est telle que, pour tout
c ∈ {0, 1}, |gk−1 (c)| = 2. En effet, dans le cas contraire, il existe c ∈ {0, 1} tel que |gk−1 (c)| ≥ 3
et, pour l 6= k, l’application (gk , gl ) ne peut pas être injective (et donc gk et gl ne sont pas
indépendantes).
Pour la même raison, s’il existe a, b, a′ , b′ ∈ {0, 1} tels que gk (a, b) = gk (a′ , b′ ), alors il
existe l 6= k tel que gl (a, b) 6= gl (a′ , b′ ). Donc, à permutation d’indices près, on suppose que
g1 (0, 0) = g1 (0, 1), g2 (0, 0) = g2 (1, 0) et g3 (0, 0) = g3 (1, 1). Ainsi, chaque gk est entièrement
déterminé par sa valeur sur (0, 0). Un simple calcul montre alors que g1 ⊕ g2 ⊕ g3 est constant.
Par exemple g1 ⊕ g2 ⊕ g3 (0, 0) = g1 ⊕ g3 (0, 0) ⊕ g2 (1, 0). Si g1 (0, 0) = g3 (0, 0) = 0, alors
g1 (1, 0) = g3 (1, 0) = 1 et g1 ⊕g3 (0, 0) = g1 ⊕g3 (1, 0). Donc g1 ⊕g2 ⊕g3 (0, 0) = g1 ⊕g2 ⊕g3 (1, 0).
Si g1 (0, 0) = g3 (0, 0) = 1 alors g1 (1, 0) = g3 (1, 0) = 0 et on a à nouveau g1 (0, 0) ⊕ g3 (0, 0) =
g1 (1, 0) ⊕ g3 (1, 0). De même, si g1 (0, 0) = 0 et g3 (0, 0) = 1 alors g1 (1, 0) = 1 et g3 (1, 0) = 0 et
g1 ⊕ g3 (0, 0) = g1 ⊕ g3 (1, 0). Le cas où g1 (0, 0) = 1 et g3 (0, 0) = 0 est symétrique. Donc on a
g1 ⊕ g2 ⊕ g3 (0, 0) = g1 ⊕ g2 ⊕ g3 (1, 0). On peut effectuer le même raisonnement pour chaque
couple d’entrées.
En appliquant le lemme 3.46 à la fois à (fˆz1 , fˆz2 , fˆz3 ) et (fˆz1 , fˆz2 , fˆz4 ) après des séquences
σ telles que σ u = 0q et σ w = 0q , on obtient le corollaire suivant :
Corollaire 3.47. Pour tout q ≥ 0, il existe ε ∈ {0, 1} tel que
∀a, b ∈ {0, 1},
fˆz3 (0q a, 0q b) = ε ⊕ fˆz4 (0q a, 0q b).
Démonstration.
Soit q ≥ 0. Soit gi : {0, 1}2 → {0, 1} défini par gi (a, b) = fˆzi (0q a, 0q b).
Le conjoint α de la spécification ϕM impose à p1 , p2 et p4 d’écrire la valeur courante du couple
(u, w), donc ils doivent être capable de distinguer les quatre valeurs possibles de ces variables.
Donc g1 , g2 et g3 sont indépendants deux à deux. En appliquant le lemme 3.46, on obtient
l’existence de ε3 ∈ {0, 1} tel que, pour tout (a, b) ∈ {0, 1}2 , g3 (a, b) = ε3 ⊕ g1 (a, b) ⊕ g2 (a, b).
De même, en considérant les valeurs des variables modifiées par p1 , p3 , p5 , on déduit que g1 , g2
et g4 sont aussi indépendants deux à deux et que g4 (a, b) = ε4 ⊕ g1 (a, b) ⊕ g2 (a, b).
Ainsi, pour tout (a, b) ∈ {0, 1}2 , on a g3 (a, b) ⊕ g4 (a, b) = ε3 ⊕ ε4 = ε et on obtient
z
fˆ 3 (0q a, 0q b) = ε ⊕ fˆz4 (0q a, 0q b).
4.2.3
Perte d’une valeur de u par p6
Soit q ≥ 0. Pour u = 0q 1u′ avec u′ ∈ {0, 1}ω , on définit u0 = 0q 0u′ . On remarque que
si u ∈ 0q 1p+1 0{0, 1}ω code p + 1 > 1, alors u0 ∈ 0q+1 1p 0{0, 1} code p. Le lemme suivant
affirme que la stratégie f z3 (respectivement f z4 ) écrit nécessairement la même séquence pour
les valeurs d’entrée u et u0 pourvu que la séquence de valeurs prises par w soit d’une certaine
96
Chapitre 3. Synthèse de systèmes synchrones
forme, de façon à ce que le processus p6 soit incapable de faire la différence entre le codage
de p et le codage de p + 1 donné par la variable d’entrée u.
Lemme 3.48. Soient u, w ∈ 0q 1{0, 1}ω . Pour k ∈ {3, 4}, pour tout n > 0, on a
fˆzk (u0 [n], w[n]) = fˆzk (u[n], w[n]).
(3.8)
Démonstration.
La preuve se fait par récurrence sur n. Si n ≤ q, u0 [n] = u[n] et (3.8)
est trivialement vérifié.
Supposons maintenant que n = q + 1, donc u0 [n] = 0q 0 et u[n] = 0q 1 = w[n]. Si
z
ˆ
3
f (0q 0, 0q 0) = fˆz3 (0q 0, 0q 1), alors d’après le corollaire 3.47 on a également fˆz4 (0q 0, 0q 0) =
fˆz4 (0q 0, 0q 1). Pour un v ∈ {0, 1}n donné, cela implique que le processus p6 a observé exactement la même histoire sur les triplets d’entrée (0q 0, 0q 0, v) et (0q 0, 0q 1, v) ; par conséquent
il écrirait à l’instant n la même valeur sur w6 dans les deux cas, ce qui violerait la condition α. Donc fˆz3 (0q 0, 0q 0) 6= fˆz3 (0q 0, 0q 1). En suivant le même raisonnement, on obtient
que fˆz3 (0q 0, 0q 0) 6= fˆz3 (0q 1, 0q 1). Comme l’application fˆz3 ne peut prendre que deux valeurs
différentes, on en déduit que fˆz3 (0q 0, 0q 1) = fˆz3 (0q 1, 0q 1). Le corollaire 3.47 nous permet
à nouveau de conclure que fˆz4 (0q 0, 0q 1) = fˆz4 (0q 1, 0q 1) et l’égalité (3.8) est vérifiée pour
n = q + 1.
Enfin, supposons que n ≥ q + 1. Par hypothèse de récurrence, pour k ∈ {3, 4}, et pour
tout i < n, on a fˆzk (u0 [i], w[i]) = fˆzk (u[i], w[i]). Donc pour tout v ∈ {0, 1}ω , pour tout
couple σ, σ0 ∈ (S V )ω , exécutions respectant F tels que σ w = σ0w = w, σ v = σ0v = v et σ u = u,
σ0u = u0 , les histoires sur z3 , σ z3 [n−1] = σ0z3 [n−1], et les histoires sur z4 , σ z4 [n−1] = σ0z4 [n−1],
sont identiques, et donc à l’instant n − 1, le processus p6 a observé exactement les mêmes
séquences de valeurs dans les deux cas : σ z3 ,z4 ,v [n − 1] = σ0z3 ,z4 ,v [n − 1].
Considérons à présent trois applications de {0, 1}2 dans {0, 1}2 définies par
h(c, d) = (f u6 , f w6 )(σ z3 [n − 1]c, σ z4 [n − 1]d, σ v [n])
h1 (a, b) = (fˆz3 , fˆz4 )(u[n − 1]a, w[n − 1]b)
h0 (a, b) = (fˆz3 , fˆz4 )(u0 [n − 1]a, w[n − 1]b)
On déduit du fait que σ z3 [n − 1] = σ0z3 [n − 1] et σ z4 [n − 1] = σ0z4 [n − 1] et de la condition
α que h est une fonction inverse de h1 et de h0 . Par conséquent, h1 = h0 et, pour k = 3, 4,
fˆzk (u[n], w[n]) = fˆzk (u0 [n], w[n]).
4.2.4
Nécessité d’écrire la n(u)-ième configuration de M sur x
Tous ces résultats intermédiaires nous assurent que toute stratégie distribuée gagnante
pour (A, ϕM ) peut, si l’environnement joue d’une certaine façon, être contrainte de faire
manquer une valeur de u au processus p6 . On montre que cela est suffisant pour retrouver
l’indécidabilité du théorème 3.13 :
Lemme 3.49. Soit σ ∈ (S V )ω une exécution respectant F . Alors pour tout p > 0 on a
∀q ≥ 0,
σ u ∈ 0q 1p 0{0, 1}ω ⇒ σ x = #p+q Cp #ω
(3.9)
avec Cp la p-ième configuration atteinte par M lors d’un calcul commençant sur la bande vide.
5. Bilan
97
Démonstration.
La démonstration se fait par récurrence sur p. Le cas p = 1 découle
directement de la spécification γM . Soit p ≥ 1, et supposons que σ u = u ∈ 0q 1p+1 0{0, 1}ω ,
σ v = v = 0q+1 1p 0ω et σ w = w = 0q 1ω . Soit également σ0 exécution respectant F tel que σ0v =
σ v , σ0w = σ w et σ0u = u0 ∈ 0q+1 1p 0{0, 1}ω . Par hypothèse de récurrence, σ0x = #q+1+p Cp #ω .
Comme σ0 |= ϕM , on déduit de la condition δ que σ0y = σ0x = #q+1+p Cp #ω . Par le lemme 3.48,
σ z3 = σ0z3 et σ z4 = σ0z4 . Ainsi, nécessairement, σ y = σ0y = #q+1+p Cp #ω comme montré cidessus. Comme u code la (p + 1)-ième configuration de M et v la p-ième, et qu’ils sont
synchronisés, la condition ψM de la spécification impose que σ x = #q+1+p Cp+1 #ω . Comme la
valeur de x ne dépend que de la valeur de u, cela conclut la démonstration.
En masquant un bit de u au processus p6 on crée de l’incertitude au sujet de la valeur de
n(u), ce qui empêche ce processus de « tricher ». Par ailleurs, le processus p0 , qui n’a lui aucune
information sur la valeur des autres variables d’entrée, sait seulement que l’information qu’a
le processus p6 sur la valeur de u peut être brouillée, et que donc ce dernier peut ne pas être
capable de tricher. Donc le processus p0 n’a pas d’autre choix que d’écrire la configuration
correcte de la machine de Turing.
Démonstration du théorème 3.44.
Pour une machine de Turing M , on a montré que
toute stratégie distribuée gagnante pour (A, ϕM ) est contrainte d’écrire sur la variable x la
n(u)-ième configuration de M . Par conséquent, il existe une stratégie distribuée gagnante pour
(A, ϕM ∧ G(x 6= halt)) si et seulement si M ne s’arrête pas lorsque son entrée est la bande
vide. On a donc réduit le problème du non-arrêt d’une machine de Turing au problème de
synthèse de systèmes distribués pour (A, ϕ) avec A architecture bien connectée à information
linéairement préordonnée, et ϕ ∈ LTL(VI ∪ VO ), démontrant par là que ce dernier problème
est indécidable.
5
Bilan
On a étudié dans ce chapitre le problème de synthèse de système distribué synchrone, pour
lequel on a proposé la légère généralisation par rapport aux résultats existants d’autoriser des
délais arbitraires pour les processus. On a choisi de se restreindre à des spécifications externes,
qui semblent plus naturelles pour décrire des comportements de systèmes distribués ouverts.
Les résultats qu’on a présentés dans ce chapitre sont résumés sur la figure 3.12. On rappelle que [FS05] ont établi pour les spécifications totales que le problème de SSD synchrones
est décidable si et seulement si l’architecture considérée est ordonnée. On a montré ici que,
dans le cas de spécifications externes, si l’architecture est à information incomparable (ce
qui représente une sous-classe des architectures non ordonnées), alors le problème de SSD
synchrone est indécidable. Par contre, on a montré que si l’architecture considérée est uniformément bien connectée, alors le problème de SSD synchrone devient décidable pour toutes les
architectures à information linéairement préordonnée. Pour continuer la comparaison avec les
spécifications totales, on en conclut que, si on considère des domaines de variables booléens
pour les architectures représentées sur la figure 3.3, alors le problème de SSD synchrone est
indécidable pour l’architecture dessinée sur la sous-figure 3.3(a), que l’on autorise des spécifications externes ou totales, décidable pour l’architecture dessinée sur la sous-figure 3.3(c),
que l’on autorise des spécifications externes ou totales, et qu’il est indécidable pour les architectures dessinées sur la sous-figure 3.3(b) si on autorise des spécifications totales, alors qu’il
devient décidable quand on se restreint à des spécifications externes.
98
Chapitre 3. Synthèse de systèmes synchrones
Malheureusement, on n’a pas trouvé pour le moment de classe plus générale d’architectures pour lesquelles être à information linéairement préordonnée deviendrait décidable. En
particulier, on a mis en lumière que s’il importe peu qu’un processus soit à même de décoder
l’information en entrée plus tard que les autres, tant que l’architecture est UWC, il est en
revanche crucial qu’il obtienne toute l’information possible. C’est pourquoi les architectures
bien connectées ne constituent pas un candidat satisfaisant. De la même manière, on pourrait
envisager une classe d’architecture dans laquelle un routage existe, mais qui n’assure pas que
l’information soit transmise au plus vite (comme c’est le cas pour les architectures UWC).
Cependant, on peut à nouveau écrire une spécification similaire à celle de la preuve du théorème 3.44, forçant le processus p2 de la figure 3.13 à perdre une valeur de la variable u, et
nous permettant à nouveau d’appliquer le lemme 3.49 afin d’aboutir à l’indécidabilité.
Une autre approche permettant d’augmenter le nombre d’architectures pour lesquelles
le problème de SSD synchrone est décidable, est de restreindre le langage de spécification.
Un point crucial des résultats d’indécidabilité est que les démonstrations reposent fortement
sur le fait que la spécification utilisée est globale (le synchronisme des exécutions permettant
aisément de lier dans une formule de logique temporelle des valeurs de variables attachées
à des processus n’ayant pas de possibilité de communiquer), alors que les contrôleurs que
l’on cherche à synthétiser sont locaux. Une première tentative de limiter ce pouvoir des spécifications a été faite dans [MT01], qui ont défini le concept de spécifications locales. Les
spécifications robustes qu’on a définies sont en fait une façon de combiner cette notion de
localité, avec la notion de spécification externe. Ceci permet d’obtenir la décidabilité du problème dès que l’architecture considérée est UWC. Cependant, il faut noter que ce résultat
n’étend pas à strictement parler les résultats de [MT01]. En effet, si on obtient techniquement plus d’architectures pour lesquelles le problème est décidable, la classe des pipelines à
double entrée n’est pas incluse dans la classe des architectures UWC : il n’existe un routage
des variables d’entrée vers les sorties dans les pipelines à double entrée que si le domaine des
variables est suffisamment grand.
99
5. Bilan
Architectures acycliques
Information incomparable
Information linéairement préordonnée
Architectures bien connectées
Architectures uniformément
bien connectées
Fig. 3.12 – Le problème de synthèse de système distribué synchrone à délai avec spécifications
externes
u
x
w
v
1
0
z1
z2
y
Fig. 3.13 – Une architecture pour laquelle le problème de SSD synchrone est indécidable
100
Chapitre 3. Synthèse de systèmes synchrones
Chapitre 4
Synthèse de systèmes asynchrones
Sommaire
1
2
3
Le modèle . . . . . . . . . . . . . . . . . . . . .
1.1
Le système . . . . . . . . . . . . . . . . . . .
1.2
Les spécifications . . . . . . . . . . . . . . . .
Résultats de décidabilité . . . . . . . . . . . .
2.1
Les structures singleton . . . . . . . . . . . .
2.2
Les architectures fortement connexes . . . . .
Bilan . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
102
102
109
116
116
126
143
Dans ce chapitre, on étudie le problème de synthèse de systèmes distribués dans le cadre
asynchrone. Comme on l’a vu dans les chapitres précédents, en particulier dans la preuve
d’indécidabilité du problème de synthèse de systèmes distribués synchrones de [PR90], le synchronisme est un facteur important d’indécidabilité : c’est le fait que le comportement du
système soit synchrone qui permet de lier dans la spécification les comportements de deux
processus qui ne peuvent communiquer et qui ont une connaissance incomparable de l’état
du système. Une façon de contourner ce problème est de limiter le pouvoir de la spécification, en lui interdisant de mettre en relation le comportement de deux processus qui ont ces
caractéristiques : c’était le sens des spécifications robustes définies dans le chapitre précédent
(définition 3.37 section 3.4 page 89). Une autre approche est de se placer dans le cadre plus
général des systèmes asynchrones.
Ici on introduit un nouveau modèle, avec une modélisation des communications par synchronisation d’actions (voir section 2.3.2 page 41). On va chercher à calculer des contrôleurs
distribués à mémoire locale (contrairement aux travaux de [GLZ04] et de [MTY05], qui autorisaient une mémoire causale). Par ailleurs, le modèle qu’on présente diffère de celui de
[MT02b] de deux manières : dans leur modèle, les architectures sont bipartites (voir définition
page 41), ce qui implique que si les processus évoluent bien de façon asynchrone les uns vis-àvis des autres, chacun communique localement avec l’environnement de façon synchrone. Ici,
on considère que les processus évoluent de façon asynchrone aussi bien vis-à-vis de l’environnement (qui peut effectuer plusieurs actions à la suite, comme ne plus rien faire jusqu’à la fin
d’une exécution) que les uns par rapport aux autres. Une seconde différence repose sur les mécanismes de synchronisation entre les processus. Dans [MT02b] ce sont des communications
par rendez-vous qui sont envisagées : une action partagée par deux processus est effectuée
uniquement si les deux processus sont d’accord pour l’effectuer. Ici, on introduit des actions
101
102
Chapitre 4. Synthèse de systèmes asynchrones
qu’on appelle signaux, qui sont unidirectionnels : on définit pour chaque signal un processus
émetteur qui peut le déclencher, et le signal est immédiatement reçu par le processus récepteur, que ce dernier désire le recevoir ou non. Ce mécanisme est plus pratique, et plus puissant
du point de vue de la synthèse que la communication par variables partagées, et plus naturel
vis-à-vis des applications pratiques que la communication par rendez-vous classique. Intuitivement, ce type de mécanisme peut correspondre dans un système réel à la possibilité pour
le processus émetteur du signal de modifier une variable appartenant au processus récepteur.
Ainsi, le processus récepteur est bien immédiatement conscient du message.
Comme dans le chapitre précédent, on n’autorisera pas les spécifications à contraindre le
comportement interne du système : les communications entre les processus ne sont restreintes
que par l’architecture, et non par la spécification. De plus, on considérera les exécutions
de nos systèmes comme étant des traces de Mazurkiewicz. Les spécifications seront donc
exprimées dans un formalisme logique ayant pour modèles des ordres partiels étiquetés par
les actions externes du système. Enfin, on va se restreindre à des spécifications bénéficiant de
propriétés de clôture naturelles, afin d’empêcher des contraintes irréalistes : on ne veut pas
empêcher de relations de causalité entre deux événements (cela restreindrait les possibilités de
communication des processus), et on ne veut pas qu’il soit possible d’imposer des causalités
irréalisables a priori. On restreint également l’ensemble des exécutions à confronter avec la
spécification aux exécutions équitables vis-à-vis de la stratégie choisie.
Dans la première section de ce chapitre, on présente plus en détail ce modèle et les spécifications que l’on va autoriser. Puis dans la seconde section, on présente les résultats de
décidabilité obtenus : dans ce cadre, on obtient la décidabilité du problème de synthèse de
systèmes distribués pour toute la sous-classe des architectures ayant un graphe de communication fortement connexe (i.e., dans lesquelles les processus peuvent tous communiquer les
uns avec les autres – directement ou non).
1
1.1
Le modèle
Le système
Types d’architectures. On s’intéresse au problème de synthèse de systèmes distribués,
dans le cadre de communications asynchrones. Comme on l’a relevé dans la section 2.3.1 (voir
en particulier le théorème 2.51 page 41), le type de communication modélisé par des variables
partagées rend le travail du contrôleur assez difficile dans une architecture asynchrone. En
effet, supposons que le processus p veuille envoyer au processus q une séquence de messages
m1 , m2 . . . . Pour ce faire, le processus commence par écrire sur une de ses variables x lues par
le processus q la valeur m1 . Mais, avant d’écrire la valeur m2 , il doit s’assurer que le processus
q a bien eu accès à la variable x. Comme le système est asynchrone, p ne peut savoir à quel
moment cela sera fait. Il doit donc attendre une sorte d’accusé de réception de la part de q,
i.e., que q modifie une de ses variables lues par p. Or, de tels accusés de réception ne sont pas
possibles dans toutes les architectures. Dans tous les cas, ces mécanismes rendent la synthèse
de programmes distribués plus difficiles.
Nous nous plaçons donc dans un modèle de communication par signaux, dans la veine de
[LT89].
Un signal est une action partagée entre des processus, mais dont le caractère activable ne
dépend que du processus émetteur, pas du récepteur. Comme dans le cas de communications
par synchronisations d’actions qu’on a présenté dans la section 2.3.2 page 41, on assimile les
1. Le modèle
103
registres du système aux processus (V = Proc), et considère que toute action a ∈ Σ peut
modifier l’état de tous les processus qu’elle peut lire, i.e., E −1 (a) = E(a). On traduit alors la
notion de signal par l’ajout d’une application owner : ΣC → Proc vérifiant, pour tout a ∈ ΣC ,
owner(a) ∈ E(a), qui associe à chaque action contrôlable son processus émetteur. Les actions
incontrôlables ΣN C sont émises par l’environnement, processus abstrait non représenté dans
l’architecture. On peut donc étendre owner en une fonction partielle owner : Σ → Proc avec
dom(owner) = ΣC . Comme on l’a dit, l’émission d’un signal ne dépend que d’un seul processus,
owner(a)
owner(a)
on impose donc : pour tout a ∈ ΣC , pour tous s1 , s2 ∈ S Proc tels que s1
= s2
,
alors a ∈ en(s1 ) si et seulement si a ∈ en(s2 ). Par exemple, si on considère deux processus
p et q et une action a telle que E(a) = E −1 (a) = {p, q} avec owner(a) = p, si p est dans un
état local dans lequel a est activable, alors quel que soit l’état local dans lequel q se trouve,
il est possible de jouer a.
Par la suite, comme dans le chapitre précédent, on va s’intéresser uniquement au problème
de synthèse. Les architectures que l’on considère sont donc telles que pour tout p ∈ Proc,
|S p | = 1, et pour tout s ∈ S Proc , en(s) = Σ. Les domaines des registres ainsi que les fonctions de transitions locales des actions sont alors des données superflues, et on définira une
architecture distribuée simplement par le tuple A = (Proc, Σ, E, owner).
Les architectures vont respecter les contraintes supplémentaires suivantes : pour tout a ∈
Σ, |E(a)| ≤ 2, i.e., on n’autorise pas d’envois de messages de type broadcast. De plus, comme
on l’a dit, le processus environnement est abstrait, les actions de communication avec l’environnement sont donc considérées comme locales. On note ces actions Γ = {a ∈ Σ | |E(a)| = 1}.
On les divise en deux catégories, les signaux émis par l’environnement, et les signaux émis
par les processus. Pour p ∈ Proc, on note Inp = {a ∈ ΣN C | E(a) = {p}} les actions émises
par l’environnement et reçues par le processus p, et Outp = {a ∈ ΣC | E(a) = {p}} les
signaux
S p vers l’environnement. On utilisera également les notations
S émis par le processus
In = p∈Proc Inp , et Out = p∈Proc Outp . Ainsi, les signaux externes sont Γ = In ∪ Out.
Les actions de Σ\Γ sont les actions de communication entre les processus. Pour p, q ∈ Proc,
on note Σp,q l’ensemble des signaux émis par p et reçus par q. Formellement, Σp,q = {a ∈ Σ |
E(a) = {p, q}, owner(a) = p}.
On note Σp les actions visibles au processus p, soit Σp = {a ∈ Σ | p ∈ E(a)}. Ces actions
sont donc les actions de communications locales avec l’environnement,
et les signaux qu’il
S
p
p,q
émet et reçoit des autres processus : Σ = Inp ∪ Outp ∪ q∈Proc Σ ∪ Σq,p . On note enfin
ΣpC le sous-ensemble des S
actions de Σp que le processus p peut contrôler : ΣpC = {a ∈ Σp |
owner(a) = p} = Outp ∪ q∈Proc Σp,q .
Exemple 4.1 (Exemple d’architecture). Considérons l’architecture à synthétiser
A = (Proc, Σ, E, owner) représentée figure 4.1. Ici, l’ensemble des processus est Proc =
{1, 2, 3}. Afin de mettre en évidence le processus émetteur de chaque signal, on a adopté
une représentation de type graphe de communication, dans lequel les flèches représentent les
différents ensembles de signaux décrits ci-dessus. L’image du haut représente la signature telle
que dessinée dans le chapitre 2, dans laquelle on a regroupé toutes les actions de même type en
un seul carré. Dans l’image du bas on représente la signature telle qu’on les dessinera dans ce
chapitre, avec les processus représentés dans des carrés pour garder une homogénéité avec le
chapitre précédent. Les actions de Σ1,2 par exemple sont bien partagées entre les processus 1
et 2, mais dans l’image du bas le sens de la flèche indique que c’est le processus 1 qui les émet.
Les signaux contrôlés par l’environnement sont représentés par des flèches entrantes sur le
graphe de communication, et les signaux externes contrôlés par les processus sont représentés
104
Chapitre 4. Synthèse de systèmes asynchrones
In1
1
In2
Σ1,2
In3
Σ2,3
2
Out1
Out2
In1
1
Out3
In2
Σ1,2
Out1
2
3
In3
Σ2,3
Out2
3
Out3
Fig. 4.1 – Un exemple d’architecture
par des flèches sortantes. On a donc par exemple, Σ2C = Out2 ∪ Σ2,3 , et Σ2 = In2 ∪ Σ1,2 ∪ Σ2C .
Exécutions du système. On se place dans un modèle totalement asynchrone dans lequel
on assimile Σ′ et Σ. On rappelle (voir la remarque 2.12 page 20) que le langage L(A) est clos
par équivalence de traces. De plus, comme nos architectures sont à synthétiser, la séquence
d’états visités au cours d’une exécution est toujours la même, et on peut assimiler L(A)
à Runs(A). On va donc considérer que les exécutions sont des traces de Mazurkiewicz de
R(Σ, D). On rappelle (voir la relation (2.1) donnée page 20) que pour tous a, b ∈ Σ, a D b si
et seulement si (E −1 (a) ∩ E(b)) ∪ (E −1 (b) ∩ E(a)) ∪ (E(a) ∩ E(b)) 6= ∅. Ici, ceci est équivalent
à E(a) ∩ E(b) 6= ∅.
Remarque 4.2. Soit α = (X, ≤, λ) ∈ R(Σ, D) une exécution. Avec ces notations, deux actions a
et b ∈ Σ sont dépendantes si et seulement si il existe un processus p ∈ Proc tel que a, b ∈ Σp .
Dans α, l’ordre entre deux événements locaux se passant sur deux processus distincts est
nécessairement induit par des actions partagées, i.e., des actions de communication. On en
déduit que pour tous processus p 6= q ∈ Proc, et événements x ∈ λ−1 (Σp ) et y ∈ λ−1 (Σq ),
si x ≤ y, alors il existe zp ∈ λ−1 (Σp \ Γ) et zq ∈ λ−1 (Σq \ Γ) tels que x ≤ zp ≤ zq ≤ y.
Les événements x et zp sont ordonnés car ils sont dépendants, ainsi que y et zq , et il existe
entre zp et zq une séquence d’événements partagés (par exemple si simplement zp = zq ∈
λ−1 (Σp,q ∪ Σq,p)).
Stratégies. On cherche à synthétiser des stratégies déterministes distribuées parmi les processus, à mémoire locale. Comme ici, nous assimilons les exécutions de A à R(Σ, D), on définit
les programmes du système sur des préfixes d’exécutions, donc sur des traces de Mazurkiewicz
finies : F : M(Σ, D) → 2Σ . La stratégie F est distribuée parmi les processus s’il existe un
tuple de stratégies (f p )p∈Proc avec f p : M(Σ, D) → ΣpC et vérifiant, pour tout α ∈ M(Σ, D),
105
1. Le modèle
F (α) = ΣN C ∪ {f p (α) | p ∈ Proc}. Ainsi, F est un programme du système non-bloquant, (il
satisfait les conditions (2.2), (2.3), et (2.4) (voir page 22).
Une stratégie à mémoire locale pour le processus p est une stratégie qui ne tient compte
que des actions visibles pour p, i.e. des actions de Σp . On rappelle que pour un ordre partiel
α = (X, ≤, λ) étiqueté par Σ, on note, pour tout Σ′ ⊆ Σ la projection de α sur Σ′ comme
étant l’ordre partiel πΣ′ (α) = (X ∩ λ−1 (Σ′ ), ≤ ∩(λ−1 (Σ′ ))2 , λ).
Définition 4.3 (Stratégie à mémoire locale). Soit f p : M(Σ, D) → ΣpC une stratégie pour le
processus p ∈ Proc. Elle est à mémoire locale si, pour tous α, α′ ∈ M(Σ, D) tels que
πΣp (α) = πΣp (α′ ),
on a
f p (α) = f p (α′ ).
Une stratégie distribuée F = (f p )p∈Proc est à mémoire locale si, pour tout p ∈ Proc, f p est à
mémoire locale.
Les stratégies des processus ne sont pas nécessairement des fonctions totales. Ici, on autorise donc un processus à s’arrêter de jouer s’il estime que la spécification est satisfaite. Par
contre, la stratégie du système, F , respectant la condition (2.3), propose toujours les signaux
de l’environnement. La stratégie ne peut donc pas imposer qu’une exécution soit finie.
Pour une trace α = (X, ≤, λ) ∈ R(Σ, D), pour x ∈ X, on notera α↓α x = (↓α x, ≤, λ) et
α⇓α x = (⇓α x, ≤, λ) les traces préfixes de α constituées respectivement des événements dans
le passé et dans le passé strict de x.
Exécutions selon une stratégie distribuée. Soit F : M(Σ, D) → 2Σ une stratégie distribuée du système, à mémoire locale. Une exécution α = (X, ≤, λ) ∈ R(Σ, D) respecte la stratégie F = (f p )p∈ Proc (ou est F -compatible), si toutes les actions contrôlables sont étiquetées
en fonction de la stratégie, i.e., pour tout p ∈ Proc, pour tout x ∈ λ−1 (ΣpC ), λ(x) = f p (α⇓α x ).
On rappelle également qu’une exécution finie α ∈ M(Σ, D) est F -maximale si F (α) ∩ ΣC = ∅.
Remarque 4.4. Pour toute stratégie F , tout événement d’une exécution étiqueté par un signal
de l’environnement respecte la stratégie, par la condition (2.3). Donc cette définition d’une
exécution F -compatible rejoint la définition donnée page 22 (définition 2.16). Par ailleurs,
contrairement au cas synchrone, pour une stratégie déterministe fixée, même si la séquence
d’actions jouée par l’environnement est fixée aussi, il existe plusieurs exécutions F -compatibles
et respectant le schéma d’actions de l’environnement, dépendant de l’ordonnancement des
actions choisi.
Exemple 4.5 (Exemple d’exécution F -compatible). Considérons l’architecture représentée
sur la figure 4.1 pour laquelle on définit l’alphabet d’actions : In1 = {req1 }, In2 = {req2 },
Σ1,2 = {msg1 }, Σ2,3 = {msg1,3 , msg2 } et Out3 = {rep1 , rep2 }. Informellement, la stratégie du
processus 1 est d’envoyer au processus 2 un signal msg1 à chaque fois qu’il reçoit un signal
req1 de l’environnement, la stratégie du processus 2 est d’envoyer un signal msg2 au processus
3 si le dernier signal reçu est req2 et msg1,2 si c’est msg1 , et la stratégie du processus 3 est
d’émettre un signal rep1 si le dernier signal reçu est msg1,3 et rep2 si le dernier message reçu
est msg2 . Alors la trace représentée sur la figure 4.2 est compatible avec cette stratégie. Ce
n’est en revanche pas une exécution maximale, la stratégie du processus 1 étant d’envoyer un
message après la réception du dernier signal de l’environnement. On a représenté à droite une
106
Chapitre 4. Synthèse de systèmes asynchrones
1
2
3
req1 msg1
req2
req1
req1
req2 msg2
req2
req1
msg1
rep2
req2 msg2
rep2
Fig. 4.2 – Une exécution F -compatible
trace comme un ordre partiel classique, et à gauche la représentation faisant explicitement
apparaı̂tre les processus. Une action partagée apparaı̂t donc sur deux processus à la fois, le
sens de la flèche mettant en évidence quel processus est émetteur du signal. La représentation
avec processus explicites permet de voir plus facilement les signaux visibles à un processus
donné, et donc ce sur quoi la stratégie prend sa décision. En effet, une stratégie à mémoire
locale ne dépend en fait que de l’histoire totalement ordonnée des actions visibles au processus
considéré.
Équité. On s’intéresse uniquement aux exécutions équitables du système. On commence par
remarquer que les notions d’équités globales telles que définies dans la définition 2.45 page 40
ne sont pas suffisantes pour éliminer les exécutions « dégénérées ».
Exemple 4.6. On reprend l’architecture de la figure 4.1, dans laquelle on suppose à présent
donnés les alphabets d’actions externes In1 = {req1 }, Out1 = {rep1 }, In2 = {req2 }, Out2 =
{rep2 }, et on considère une spécification informelle qui demande : « Toute requête req1 est
suivie d’une réponse rep1 , et toute requête req2 est suivie d’une réponse rep2 ». Une telle
spécification est en fait une conjonction de restrictions sur des comportements locaux des
processus, et ne devrait pas être plus difficile à réaliser que sur une architecture constituée
d’un seul processus. En particulier, la stratégie F telle que, pour i = 1, 2, f i propose de
jouer repi à chaque fois que le processus i reçoit un signal reqi devrait être gagnante. Or,
l’exécution dans laquelle le processus 2 reçoit un signal req2 et ne joue jamais, tandis que le
processus 1 joue une infinité de signaux rep1 est compatible avec cette stratégie, et faiblement
équitable au sens global de la définition 2.45, mais ne satisfait pas la spécification.
Il est donc naturel de demander que chaque processus ait les mêmes chances d’envoyer un
signal s’il le désire. On va considérer par conséquent une notion d’équité plus locale.
Pour exprimer la notion d’équité en toute généralité, on la définit en fonction d’une partition des actions de ΣC . La partition la plus grossière correspond à une équité globale.
L’exemple 4.6 indique qu’il est plus intéressant de se restreindre aux partitions comprises
entre celle faite en fonction des actions contrôlables des processus : P = {ΣpC | p ∈ Proc} et
la partition la plus fine des actions : P = {{a} | a ∈ ΣC }.
Pour α, α′ ∈ R(Σ, D) on note α ≤ α′ pour « α est une trace préfixe de α′ » et on définit
formellement les exécutions équitables comme suit :
Définition 4.7 (Exécutions équitables). On dit qu’une exécution α = (X, ≤, λ) ∈ R(Σ, D) est
F -équitable pour une partition P des actions contrôlables ΣC si, pour tout Σ′ ∈ P, s’il existe
107
1. Le modèle
α′ ∈ M(Σ, D) préfixe de α telle que, pour toute trace α′′ telle que α′ ≤ α′′ ≤ α, F (α′′ )∩Σ′ 6= ∅,
alors λ−1 (Σ′ ) est infini.
Remarque 4.8. Une exécution finie est F -équitable si et seulement si elle est F -maximale. En
effet, soit α ∈ M(Σ, D) une exécution F -compatible finie. Si F (α) ∩ ΣC 6= ∅ (et donc α n’est
pas F -maximale), alors il existe Σ′ un élément de la partition, et un préfixe fini α′ = α de α tel
que pour tout α ≤ α′′ ≤ α, F (α′′ ) ∩ Σ′ 6= ∅. Or, α étant fini, on a λ−1 (Σ′ ) nécessairement fini.
Donc α n’est pas F -équitable. Si réciproquement, α est F -maximale, alors F (α) ∩ ΣC = ∅,
et donc pour tout Σ′ ∈ P, pour tout α′ ∈ M(Σ, D), il existe α′′ = α tel que F (α′′ ) ∩ Σ′ = ∅.
L’exécution est donc F -équitable car satisfaisant trivialement l’implication.
Remarque 4.9. La définition 4.7 revient à dire que pour toute trace préfixe α′′ = (X ′′ , ≤, λ)
telle que α′ ≤ α′′ ≤ α, il existe x ∈ X \ X ′′ tel que λ(x) ∈ Σ′ .
Par la suite, sauf mention contraire, on va s’intéresser à la notion la plus forte d’équité
locale, qu’on appellera équité locale forte 1 , c’est-à-dire à la partition des actions P = {ΣpC |
p ∈ Proc}. Les exécutions équitables seront donc celles correspondant à la définition suivante,
qui est une reformulation de la définition 4.7 :
Définition 4.10. On dit qu’une exécution α = (X, ≤, λ) ∈ R(Σ, D) est F -équitable si, pour
tout processus p ∈ Proc, s’il existe α′ ∈ M(Σ, D) préfixe de α telle que, pour toute trace α′′
telle que α′ ≤ α′′ ≤ α, F (α′′ ) ∩ ΣpC 6= ∅, alors λ−1 (ΣpC ) est infini.
Les spécifications. Comme dans le chapitre 3, on affirme que les spécifications raisonnables
à considérer sont de type externe. En effet, on veut que les processus soient libres de collaborer
sans restriction afin de se conformer aux comportements autorisés. On se restreint donc à des
spécifications ne contraignant que les actions de Γ, qui sont les actions de communication
avec l’environnement. De plus, nos spécifications seront sur des ordres partiels. En effet, dans
ce modèle, on définit les exécutions comme étant déjà des traces de Mazurkiewicz, donc des
ordres partiels. Il est donc logique que la spécification ait comme modèles des ordres partiels.
Par ailleurs, comme on l’a déjà signalé dans la section 2.3.3 page 46, des spécifications sur
des linéarisations des exécutions pourraient faire la distinction entre deux linéarisations de la
même exécution (en accepter une et en rejeter l’autre), ce qui n’est pas désirable.
Pour répondre à ces deux exigences, les spécifications seront donc données dans un formalisme logique dont les modèles sont des ordres partiels étiquetés par Γ.
Pour une exécution concrète du système, α = (X, ≤, λ) ∈ R(Σ, D) on définit sa partie
observable (dénommée exécution abstraite, ou exécution observable) par
πΓ (α) = (λ−1 (Γ), ≤ ∩(λ−1 (Γ))2 , λ).
On dira qu’une exécution concrète α satisfait une spécification ϕ si sa projection πΓ (α) satisfait
ϕ. On remarque que les exécutions observables sont des ordres partiels étiquetés par Γ ayant
la caractéristique que, pour tout processus p ∈ Proc, l’ensemble des événements de λ−1 (Σp )
est totalement ordonné.
Exemple 4.11. Reprenons l’architecture représentée sur la figure 4.1 mais restreinte aux
processus 1 et 2. On considère l’alphabet d’actions In1 = {req1 }, In2 = {cancel}, Σ1,2 =
1
Cette appellation peut prêter à confusion : en effet, la notion d’équité que l’on définit correspond à ce qui
est généralement appelé « équité faible ». On appelle ici équité locale forte, l’équité « faible » la plus forte du
point de vue de la partition des actions.
108
Chapitre 4. Synthèse de systèmes asynchrones
1
2
req1 rep1 msg1
cancel2
req1 rep1
ack2
1
2
req1 rep1
cancel2
req1 rep1
ack2
Fig. 4.3 – Une exécution concrète et sa partie observable
{msg1 }, Out1 = {rep1 } et Out2 = {rep2 , ack2 }. L’exécution représentée sur la figure 4.3
satisfait la spécification informelle « Toute action de type req1 est suivie par une action de
type rep1 et (par une réponse de type rep2 si et seulement si il n’y a pas eu de signal cancel2 )
et toute action de type cancel2 est suivie par une action ack2 ». On rappelle que le signal msg1
est bien une action partagée entre les processus 1 et 2 – le sens de la flèche n’est représenté
que pour indiquer le sens du signal. Ceci explique la causalité apparaissant entre cancel2 et
req1 dans la partie observable de l’exécution.
Remarque 4.12. Les ordres partiels observables, modèles de nos spécifications, ne sont plus
des traces de Mazurkiewicz. On perd en particulier la relation surjective [ ] définie dans la
section 1.1.4 page 11 liant les linéarisations des exécutions et les ordres partiels correspondants
(i..e., on peut trouver deux ordres partiels distincts ayant une linéarisation commune).
Le problème de synthèse de systèmes distribués. Afin de laisser le plus de latitude
possible aux processus, on modifie légèrement la façon dont on donne le problème : on laisse
aux processus le loisir de choisir leur alphabet de communication. La donnée du problème
est maintenant un tuple S = (Proc, R, (Inp )p∈Proc , (Outp )p∈Proc ) (qu’on appellera une structure) où (Proc, R) est un graphe de communication dont les nœuds sont les processus, et
dans lequel il existe un arc (orienté) (p, q) ∈ R si le processus p peut envoyer un signal
au processus q, et les tuples (Inp )p∈Proc et (Outp )p∈Proc forment l’alphabet des signaux externes (le graphe représenté figure 4.1 est un graphe de communication pour la structure
S = (Proc, R, (Inp )p∈Proc , (Outp )p∈Proc ) où Proc = {1, 2, 3} et R = {(1, 2), (2, 3)}). Pour définir un programme satisfaisant une spécification ϕ, on commence par définir des alphabets de
communication Σp,q pour tous les (p, q) S
∈ R. L’architecture distribuée induite est donnée par
A = (Proc, Σ, E, owner) avec Σ = Γ ∪ (p,q)∈R Σp,q et pour tout p ∈ Proc, a ∈ Inp ∪ Outp ,
E(a) = E −1 (a) = {p} et pour tout (p, q) ∈ R, pour tout a ∈ Σp,q , E −1 (a) = E(a)
S = {p, q}.
La fonction owner est définie par, pour tout p ∈ Proc, pour tout a ∈ Outp ∪ (p,q)∈R Σp,q ,
owner(a) = p.
Formellement, le problème considéré ici est :
Définition 4.13 (Le problème de SSD asynchrone équitable). Étant données une structure
S = (Proc, R, (Inp )p∈Proc , (Outp )p∈Proc ), une spécification ϕ sur les ordres partiels étiquetés
par Γ = In ∪ Out, existe-t-il
– des alphabets de communication (Σp,q )(p,q)∈R induisant une architecture distribuée A,
– et une stratégie distribuée F = (f p )p∈Proc pour A, à mémoire locale, telle que toute
exécution F -compatible et F -équitable α ∈ R(Σ, D) soit telle que πΓ (α) satisfait la
spécification ϕ ?
On dira alors que le couple ((Σp,q )(p,q)∈R , F ) satisfait (S, ϕ), ou encore que la stratégie
distribuée F est une stratégie gagnante pour (A, ϕ).
109
1. Le modèle
a
b
p
q
r
c
(a) La spécification décrit le comportement souhaité
p
q
r
a
b
a
a
b
c
b
c
c
(b) Trois exécutions concrètes du système
p
q
r
a
b
a
a
b
c
c
b
c
(c) Les exécutions observables correspondantes
Fig. 4.4 – Les spécifications doivent être closes par extension d’ordre
Remarque 4.14. La notion de stratégie équitable, sauf mention contraire, fait référence à
l’équité locale forte (définition 4.10).
1.2
1.2.1
Les spécifications
Spécifications acceptables
On explique à présent que, bien que l’on se soit déjà restreint aux spécifications sur des
ordres partiels, toutes les spécifications ne sont pas pour autant acceptables dans ce modèle.
On commence par donner un exemple montrant que les spécifications doivent être closes par
extension d’ordre.
Exemple 4.15. Considérons la structure de la figure 4.1, dans lequel le processus 1 ne peut
envoyer de signal directement à 3. Si on suppose que a ∈ In1 , b ∈ Out2 et c ∈ Out3 , une
spécification naturelle peut demander que le processus 2 effectue l’action visible b, et que, par
ailleurs, si le processus 1 reçoit le signal a de l’environnement, alors le processus 3 doit émettre
le signal c en conséquence. L’ordre partiel correspondant est représenté figure 4.4(a) (en effet,
la spécification n’imposant aucune relation de causalité entre b et les autres signaux, ceci se
traduit dans les modèles d’ordre partiel par une absence d’ordre entre b et les autres signaux).
Pour satisfaire cette spécification, le processus 1 doit, après la réception d’un signal a émis par
l’environnement, envoyer un signal au processus 3 (signal qui doit nécessairement transiter par
2 de par la structure de l’architecture distribuée) qui, en conséquence, émet le signal observable
c. Mais ces signaux internes induisent de l’ordre supplémentaire dans les exécutions selon
cette stratégie (voir figure 4.4(b)). En conséquence, on obtient les ordres partiels abstraits
correspondants représentés figure 4.4(c), et on remarque qu’aucun d’eux n’est un modèle de
la spécification, bien qu’ils en soient tous des extensions. Afin que cette spécification ait un
programme distribué la satisfaisant, on doit nécessairement autoriser également les extensions
d’ordre correspondantes.
Remarque 4.16. Cet exemple donne une justification technique à cette restriction supplémentaires des spécifications. On fait remarquer que, par ailleurs, ne pas se restreindre aux
110
Chapitre 4. Synthèse de systèmes asynchrones
c
s
req
req
rep
rep
req
req
rep
req
tr
pret
req
tr
rep
pret
rep
(b) Exécution respectant une stratégie correspondante
(a) Spécification naı̈ve
c
s
c
s
rep
(c) Spécification affaiblie
c
s
req
tr
req
pret
rep
pret
tr
rep
(d) Exécution respectant une stratégie correspondante
Fig. 4.5 – Client–Serveur
spécifications closes par extension reviendrait à autoriser la spécification à empêcher certains
processus de communiquer. En effet, l’exemple ci-dessus met bien ce fait en lumière, pour
que deux signaux soient concurrents dans une exécution abstraite, il faut qu’il n’y ait eu aucune communication entre les processus concernés entre ces deux événements. Donner un tel
pouvoir à la spécification est contraire à la notion de spécification externe que l’on cherche,
dans laquelle on ne veut restreindre les possiblités de communication des processus que par
la structure donnée en entrée du problème.
On montre à présent qu’une spécification doit également être close par un certain affaiblissement d’ordre, i.e., si un ordre partiel α est modèle de la spécification, alors certains ordres
partiels dont α est une extension doivent aussi être modèle de la spécification. La raison est
que les signaux émis par l’environnement sont des actions incontrôlables pour le système. En
conséquence, il paraı̂t irréaliste d’essayer d’imposer une relation de causalité directe entre une
action ayant lieu sur un processus donné, et une action contrôlée par l’environnement sur un
autre processus. Par exemple, considérons une structure formée de deux processus, c et s,
l’un recevant des requêtes de service d’un client, et l’autre satisfaisant ces requêtes avec les
actions externes : Inc = {req} et Outs = {rep} telle que R = {(c, s), (s, c)}.
Une spécification naı̈ve pourrait demander une alternance stricte de signaux req et rep,
comme représenté sur la figure 4.5(a). Un exemple d’exécution concrète, utilisant les signaux
internes tr et pret, la satisfaisant est représenté figure 4.5(b). Cependant, les signaux émis
par l’environnement étant incontrôlables, on ne peut pas contraindre le second signal req
à arriver après le signal interne pret. Une exécution concrète dans laquelle les processus se
comportent de la même façon, mais dans laquelle l’environnement envoie ses signaux à des
instants différents est représentée sur la figure 4.5(d), et l’exécution abstraite correspondante
sur la figure 4.5(c). On affirme donc qu’une spécification raisonnable ayant pour modèle l’ordre
partiel de la figure 4.5(a) doit aussi avoir pour modèle l’ordre partiel de la figure 4.5(c).
Remarque 4.17. La notion d’affaiblissement ne concerne que les signaux de l’environnement
se passant sur un processus « distant ». On pourrait appliquer le même raisonnement et
interdire aux spécifications d’imposer des causalités directes entre un signal et un signal émis
par l’environnement, même s’ils arrivent sur le même processus. Cependant, un signal de
l’environnement arrivant sur un processus donné est immédiatement connu par ce dernier,
et le processus a l’opportunité de changer sa stratégie pour sa prochaine action en fonction
du moment où l’action de l’environnement a eu lieu. Dans l’exemple ci-dessus par contre, le
processus s ne peut pas changer de stratégie car il ne peut pas immédiatement connaı̂tre le
111
1. Le modèle
nouveau signal émis par l’environnement.
Il est cependant envisageable de définir une notion plus restrictive des spécifications acceptables, leur interdisant d’imposer qu’un signal incontrôlable soit causé (i.e. dans le futur)
par un signal contrôlable, même si ces deux derniers mettent en jeu le même processus.
Formellement, si un ordre partiel t = (X, ≤t , λ) satisfait une spécification et si x ⋖t x′ ,
avec x′ un signal émis par l’environnement et x, x′ n’étant pas des actions arrivant sur le
même processus alors l’affaiblissement s = (X, ≤s , λ) défini par ≤s =≤t \{(x, x′ )} doit aussi
satisfaire la spécification (on remarque que, comme x′ est un successeur de x, ≤s reste une
relation d’ordre).
On définit à présent l’ordre partiel le plus faible induit par t. On rappelle que les actions de
Γ sont soitS
des entrées de l’environnement,
soit des sorties vers l’environnement : Γ = In∪Out,
S
avec In = p∈Proc Inp et Out = p∈Proc Outp . Soit un ordre partiel t = (X, ≤, λ). On définit
Wt = {(x, x′ ) ∈ X 2 | ∃p ∈ Proc, λ(x) ∈
/ Σp ∧ λ(x′ ) ∈ Inp ∧ x < x′
(4.1)
′
∧ (¬∃y, λ(y) ∈ Outp ∧ x < y < x )}.
L’ensemble Wt correspond aux paires d’événements (x, x′ ) pour lesquels l’ordre dans t est
fortuit. Ceci arrive quand x et x′ sont sur des processus différents, et que x′ est un signal
de l’environnement, sauf s’il existe un événement y entre x et x′ , correspondant à un signal
contrôlable qui se trouve sur le même processus que x′ . En effet, l’événement y peut avoir
été déclenché par x, donc on doit conserver l’ordre entre x et y (qui peut correspondre à une
causalité réelle donc), et on conserve également l’ordre entre y et x′ qui ont eu lieu sur le
même processus (voir remarque 4.17).
Remarque 4.18. Si t = (X, ≤t , λ) est un ordre partiel, la relation ≤s =≤t \Wt est également
une relation d’ordre. En effet, il est facile de voir qu’elle est réflexive et antisymétrique. On
peut également montrer que c’est une relation transitive. Soit x, y, z ∈ X, tels que x ≤s y
et y ≤s z. Alors x ≤t y, y ≤t z et (x, y) ∈
/ Wt et (y, z) ∈
/ Wt . De plus, par transitivité de
≤t , x ≤t z. S’il existe p ∈ Proc tel que x, z ∈ λ−1 (Σp ) alors il est clair que (x, z) ∈
/ Wt et
′
donc x ≤s z. Sinon, soit p, p′ ∈ Proc tels que x ∈ λ−1 (Σp ) et z ∈ λ−1 (Σp ). Si λ(z) ∈ Outp′ ,
alors on obtient immédiatement (x, z) ∈
/ Wt . Si λ(z) ∈ Inp′ , deux cas sont envisageables. Si
′
′
/ Wt qu’il existe z ′ ∈ λ−1 (Σp )
y ∈ λ−1 (Σp ), alors on déduit de l’hypothèse que x ≤t y et (x, y) ∈
tel que λ(z ′ ) ∈ Outp′ et x <t z ′ ≤t y. Donc il existe z ′ ∈ λ−1 (Outp′ ) tel que x <t z ′ <t z et
on en conclut que (x, z) ∈
/ Wt . Sinon, on utilise le fait que y ≤s z, donc il existe à nouveau
/ Wt .
z ′ ∈ λ−1 (Outp′ ) tel que y <t z ′ <t z, et comme x ≤t y, on a x <t z ′ <t z et donc (x, z) ∈
Ainsi, on peut conclure que x ≤s z et que la relation ≤s est bien une relation d’ordre.
On définit à présent les spécifications acceptables :
Définition 4.19 (Spécifications acceptables). Une spécification est acceptable si elle est
close par extension et affaiblissement d’ordre. Formellement, une spécification ϕ est acceptable
si, pour tout t = (X, ≤, λ), ordre partiel étiqueté par Γ tel que, pour tout p ∈ Proc, λ−1 (Σp )
est totalement ordonné, si t |= ϕ alors
– pour tout r = (X, ≤r , λ) tel que ≤t ⊆ ≤r , r |= ϕ (clôture par extension),
– l’ordre partiel s = (X, ≤s , λ) défini par ≤s = ≤t \ Wt , est tel que s |= ϕ (clôture par
affaiblissement).
On remarque que cette définition de l’affaiblissement supprime toutes les relations d’ordre
fortuites dans t à la fois mais, puisque la spécification est également close par extension, tous
les ordres partiels intermédiaires sont aussi capturés dans cette définition.
112
Chapitre 4. Synthèse de systèmes asynchrones
1
2
a
1
b
c
2
a
b
c
Fig. 4.6 – Un ordre partiel et son extension
1.2.2
AlocTL
Parmi les différentes logiques disponibles pour exprimer des spécifications sur des ordres
partiels, on va se concentrer sur les logiques temporelles locales, car elles permettent d’exprimer facilement et intuitivement des spécifications pour des systèmes distribués, et parce
qu’elles ont une complexité raisonnable [GK07]. Cependant, elles ne sont pas toutes acceptables. Considérons la logique locTL introduite dans [DG01], dont les formules sont évaluées
sur les éléments d’un ordre partiel, et dont la syntaxe est donnée par la grammaire suivante :
ϕ ::= ⊥ | a ∈ Σ | ¬ϕ | ϕ ∨ ϕ | EX ϕ | ϕ U ϕ | ϕ EU ϕ | EY ϕ | ϕ S ϕ | ϕ ES ϕ.
dans laquelle le symbole ⊥ signifie faux, EX ϕ signifie que ϕ est vérifiée pour un successeur
immédiat de l’élément courant, ϕ U ψ signifie que ψ est vérifiée pour un événement plus grand
que l’événement courant, et que ϕ est vérifiée sur tous les éléments entre les deux, alors que
ϕ EU ψ signifie que ψ est vérifiée pour un événement plus grand que l’élément courant et qu’il
existe un chemin allant du nœud courant au nœud vérifiant ψ sur lequel ϕ est toujours vraie.
Les modalités EY, S et ES correspondent aux modalités passées duales (pour une définition
formelle de la sémantique de locTL, voir [DG01]). Comme un ordre partiel peut avoir plusieurs
événements minimaux, se pose la question du point de départ de l’interprétation de la formule.
Ce problème est résolu dans [DG01] en ajoutant la notion de formule initiale : on vérifie qu’un
ordre partiel donné est un modèle d’une formule de locTL initiale dont la syntaxe est donnée
par
α ::= ⊥ | EM ϕ | ¬α | α ∨ α
où t |= EM ϕ si et seulement si il existe x élément minimal de t tel que t, x |= ϕ.
Remarquons à présent que les formules locTL suivantes : EM(a ∧ ¬ F b) ou EM(a ∧ EX c)
ne sont pas closes par extension d’ordre. En effet, pour rester dans la classe des spécifications
closes par extension, on doit éliminer les modalités permettant d’imposer que deux événements soient concurrents. Si la négation d’une modalité F viole clairement cette contrainte,
c’est peut-être moins évident pour le deuxième exemple de spécification. La figure 4.6 met
en lumière pourquoi : l’ordre partiel à gauche satisfait la spécification, mais son extension
représentée à droite ne la satisfait pas : en fait imposer que l’action c sur le processus 2 soit
l’événement successeur de l’action a du processus 1 revient ici à imposer que b soit concurrent
de a.
Afin d’obtenir la clôture par affaiblisement, on restreint l’usage de la relation d’ordre entre
deux événements ayant lieu sur des processus différents aux cas où le plus grand des deux
n’est pas un signal émis par l’environnement.
113
1. Le modèle
On introduit à présent une restriction syntaxique d’une logique temporelle locale basée
sur les processus (comme locTL), dans laquelle toutes les formules sont des spécifications
acceptables.
La syntaxe de la logique AlocTL(Γ, Proc) (ou simplement AlocTL si Γ et Proc sont évidents
par le contexte) est donnée par :
ϕ ::= a | ¬a | ¬ Xp ⊤ | ¬ Yp ⊤ | ϕ ∨ ϕ | ϕ ∧ ϕ
| Xp ϕ | ϕ Up ϕ | Gp ϕ | Fp,q (Out ∧ ϕ) | Yp ϕ | ϕ Sp ϕ | Out ∧ Hp,q ϕ
où a ∈ Γ et p, q ∈ Proc. Les modalités Xp , Yp , Up and Sp sont les next, yesterday, until et
since usuels, seulement restreints aux événements totalement ordonnés du processus p. On
peut aussi exprimer dans notre logique release (dual de until) : ϕRp ψ = (Gp ψ)∨(ψUp (ϕ∧ψ)).
Lorsqu’on se restreint aux événements du processus p, notre logique a le pouvoir d’expression
de LTL ou FO. On restreint uniquement la façon de passer d’un processus à un autre, afin que
les clôtures par extension et affaiblissement soient obtenues : pour cela on utilise Fp,q ou Hp,q .
La première modalité permet de spécifier une propriété réponse déclenchée sur le processus
p et dont l’action de réponse est effectuée par le processus q – par exemple Gp (requete →
Fp,q (Out∧reponse)). La seconde modalité peut être utilisée pour spécifier que certains signaux
envoyés à l’environnement doivent avoir une cause – par exemple Gp (reponse → Out ∧
Hp,q requete)). On n’inclut pas de modalités de la forme Xp,q car elles ne permettent pas de
rester dans la classe des spécifications acceptables (comme illustré par la figure 4.6).
Pour ϕ ∈ AlocTL(Γ, Proc), la sémantique définit, pour t = (X, ≤, λ) un ordre partiel
étiqueté par Γ, tel que pour tout p ∈ Proc l’ensemble X p = λ−1 (Σp ) est totalement ordonné,
et pour x ∈ X, à quelle condition t, x |= ϕ :
– t, x |= a ∈ Γ si et seulement si λ(x) = a,
– t, x |= ¬a si et seulement si λ(x) 6= a,
– t, x |= ¬ Xp ⊤ si et seulement si x ∈
/ X p ou, pour tout y ∈ X p , y ≤ x,
– t, x |= ¬ Yp ⊤ si et seulement si x ∈
/ X p ou, pour tout y ∈ X p , x ≤ y,
– t, x |= Xp ϕ si et seulement si x ∈ X p et il existe y ∈ X p tel que x < y, et pour tout
z ∈ X p z ≤ x ou y ≤ z, et t, y |= ϕ,
– t, x |= ϕ Up ψ si et seulement si x ∈ X p et il existe y ∈ X p tel que x ≤ y et t, y |= ψ et
pour tout z ∈ X p , si x ≤ z < y alors t, z |= ϕ,
– t, x |= Gp ϕ si et seulement si x ∈ X p et, pour tout y ∈ X p tel que x ≤ y, t, y |= ϕ,
– t, x |= Fp,q (ϕ ∧ Out) si et seulement si x ∈ X p et il existe y ∈ X q , tel que x ≤ y,
λ(y) ∈ Out et t, y |= ϕ,
– t, x |= Yp ϕ si et seulement si x ∈ X p et il existe y ∈ X p , y < x et pour tout z ∈ X p ,
z ≤ x ou x ≤ z, et t, y |= ϕ,
– t, x |= ϕ Sp ψ si et seulement si x ∈ X p , et il existe y ∈ X p tel que y ≤ x et t, y |= ψ, et
pour tout z ∈ X p , si y < z ≤ x, alors t, z |= ϕ,
– t, x |= Out ∧ Hp,q ϕ si et seulement si x ∈ X p , λ(x) ∈ Out et il existe y ∈ X q tel que
y ≤ x et t, y |= ϕ.
Pour déterminer si un ordre partiel donné satisfait la spécification, on doit déterminer où
commencer l’évaluation de la formule. Comme mentionné plus haut, contrairement au cas des
mots ou des arbres, il peut y avoir plusieurs éléments minimaux à un ordre partiel. Comme
dans [DG01], on choisit d’introduire des formules initiales pour traiter ce problème.
Dans notre cas, les formules initiales sont données par
α ::= ⊥ | ⊤ | ¬ EMp ⊤ | EMp ϕ | α ∨ α | α ∧ α
114
Chapitre 4. Synthèse de systèmes asynchrones
où ϕ est une formule AlocTL.
Pour t = (X, ≤, λ) ordre partiel étiqueté par Γ tel que pour tout p ∈ Proc l’ensemble
p
X = λ−1 (Σp ) est totalement ordonné, pour tout α, formule initiale de AlocTL, la sémantique
est donnée par
– t 6|= ⊥,
– t |= ⊤,
– t |= EMp ϕ si et seulement si il existe x ∈ X p , tel que pour tout x′ ∈ X, si x′ ≤ x alors
x′ ∈
/ X p , et t, x |= ϕ,
La sémantique des combinaisons booléennes de formules initiales est classique.
Exemple 4.20 (Exemples de formules AlocTL). Considérons la structure représentée sur la
figure 4.7.
1. Si on la dote de l’alphabet Inp = {req} et Outq = {rep}, alors la spécification
ϕ = EMp (Gp (req → Fp,q (Out ∧ rep)))
signifie que toute requête reçue par le processus p doit être ultérieurement suivie par
une réponse. L’exécution représentée figure 4.7(b) satisfait la spécification. En effet, les
deux premières requêtes sur le processus p sont suivies par la deuxième réponse sur
le processus q (la causalité étant induite par le signal de p vers q apparaissant entre
la deuxième requête et la deuxième réponse), et la troisième requête est suivie par la
troisième réponse (la causalité étant induite par le signal de p vers q apparaissant entre
la troisième requête et la troisième réponse).
2. Avec le même alphabet externe, on peut écrire également la spécification
ϕ = EMq (Gq (rep → (Out ∧ Hq,p req))).
Cette spécification signifie que toute réponse donnée par le processus q a été déclenchée par une requête reçue par le processus p. On remarque qu’alors l’exécution observable correspondant à l’exécution concrète représentée figure 4.7(b) ne satisfait pas
cette nouvelle spécification. En effet, la première réponse apparaı̂t de façon « spontanée », il n’existe aucun événement dans son passé, donc aucun événement de type req
sur le processus p. Par contre, l’exécution abstraite induite par l’exécution représentée
figure 4.7(c) satisfait cette spécification, bien qu’elle ne satisfasse plus la spécification
précédente (la dernière requête n’étant suivie d’aucune réponse).
3. Si on dote cette structure de l’alphabet Inp = {req}, Inq = {on, off} et Outq = {rep},
on peut exprimer la spécification un peu plus complexe suivante :
ϕ = EMq (¬(Gq Fq on)) ∨ EMp (Gp (req → Fp,q (Out ∧ rep ∧ (¬off Sq on))))
∧ EMq (Gq (rep → (Out ∧ Hq,p req))).
En fait, on veut à nouveau que toute requête sur le processus p soit suivie par une
réponse sur le processus q, mais on ajoute la contrainte que les réponses ne peuvent être
envoyées que si le processus q est en configuration on, ce qui arrive lorsque le dernier
signal de l’environnement reçu par q est on. Formellement, la sous-formule écrite sur
la première ligne est en fait une implication : s’il existe dans le futur de toute action
sur le processus q un signal de type on, alors toutes les requêtes sur le processus p sont
suivies par une réponse sur le processus q, et cette réponse arrive après un signal on suivi
115
1. Le modèle
req
p
p
q
rep
q
(a) Une structure
p
q
req
req
p
rep
q
rep
req
on
q
(c) Exécution 2
p
req
rep
(b) Exécution 1
req
rep
req
req
off
(d) Exécution 3
req
req
on
req
off
on rep
(e) Exécution 4
Fig. 4.7 – Exemple d’architecture et d’exécutions
d’aucun signal off. Par ailleurs la deuxième ligne de la spécification demande une fois
de plus qu’il n’y ait pas de réponse spontanée, déclenchée par aucune requête. Les deux
parties abstraites des exécutions représentées sur les figures 4.7(d) et 4.7(e) satisfont
la spécification : la première car EMq (¬(Gq Fq on)) est vérifiée : au point off il n’y a
aucun événement dans le futur sur le processus q vérifiant on, la deuxième, car l’unique
réponse émise par le processus q est bien dans le futur des trois requêtes reçues par le
processus p.
Proposition 4.21. La logique AlocTL est close par extension et affaiblissement.
Démonstration.
Soit t = (X, ≤t , λ) un ordre partiel étiqueté par Γ tel que X p = λ−1 (Σp )
est totalement ordonné pour tout p ∈ Proc, soit s = (X, ≤s , λ) avec ≤s = ≤t \ Wt l’affaiblissement de t, et soit r = (X, ≤r , λ) tel que ≤s ⊆ ≤r une extension de s. On montre par
récurrence sur la structure des formules que t, x |= ϕ implique que r, x |= ϕ pour tout x ∈ X.
L’affirmation est claire pour a et ¬a, ainsi que pour la disjonction et la conjonction.
Comme les restrictions de ≤t et ≤r à X p induisent le même ordre total, l’étape de récurrence
est facile pour les modalités Xp , Yp , Gp , Up and Sp qui sont restreintes au processus p. Si
t, x |= Fp,q (Out ∧ ϕ) alors x ∈ X p et il existe y ∈ X q tel que x ≤t y, λ(y) ∈ Out et t, y |= ϕ.
Comme y est un événement de type sortie, alors on a x ≤s y et donc également x ≤r y.
116
Chapitre 4. Synthèse de systèmes asynchrones
On en déduit immédiatement que r, x |= Fp,q (Out ∧ ϕ). La preuve est similaire pour le cas
Out ∧ Hi,j ϕ.
Enfin, t et r ont le même éventuel événement minimal sur le processus p, donc t |= EMp ϕ
implique que r |= EMp ϕ et t |= ¬ EMp ⊤ implique que r |= ¬ EMp ⊤. L’implication est donc
vraie aussi pour les formules initiales.
On rappelle que lorsqu’on se restreint aux événements d’un seul processus p, cette logique
a le même pouvoir d’expression que LTL ou FO. On restreint uniquement la façon dont on
peut passer d’un processus à un autre, afin d’obtenir les clôtures par extension et par affaiblissement. Ainsi, on pourrait également définir une version plus forte d’AlocTL ayant le pouvoir
d’expression de MSO sur les formules ne concernant les événements que d’un processus. On
a choisi de définir cette logique afin d’avoir un exemple de formalisme pour les spécifications
acceptables, suffisamment expressif pour permettre des spécifications intéressantes. Cependant les résultats présentés dans ce chapitre restent vrais pour tout langage de spécification
clos par extension et affaiblissement (logiques plus fortes, automates présentant de bonnes
propriétés de clôture, etc.)
2
Résultats de décidabilité
Dans cette section, on résoud le problème de SSD asynchrone équitable pour la sous-classe
de structures ayant un graphe de communication sous-jacent (Proc, R) fortement connexe :
chaque processus peut envoyer des signaux à n’importe quel autre processus (éventuellement
en utilisant des processus intermédiaires). Par la suite, nous appellerons plus simplement ces
structures des structures fortement connexes.
Fig. 4.8 – Des structures fortement connexes
Par la suite, on sera amené à considérer des exécutions observables particulières qui seront
des ordres totaux.
2.1
Les structures singleton
Une première étape pour résoudre le problème général est de le résoudre pour le cas
particulier de structures constituées d’un unique processus : les structures singleton. Dans ce
2. Résultats de décidabilité
117
cas précis, il n’y a pas d’action interne, donc Σ = Γ = In∪Out et toutes les exécutions sont des
ordres totaux. De plus les notions de structures et d’architectures induites se confondent. On
parlera donc indifféremment d’architectures singleton ou de structures singleton. On assimilera
ici les ordres totaux étiquetés par Γ et les mots de Γ∞ . Enfin, puisqu’il n’y a ni extension ni
affaiblissement possible, on utilise les logiques classiquement utilisées pour les spécifications.
On va de plus montrer un résultat un peu plus fort que la décidabilité du problème de
SSD asynchrone équitable de la définition 4.13 ; on va montrer que, pour toute partition des
actions contrôlables, le problème de SSD asynchrone équitable selon la définition d’équité
générale 4.7 est décidable. Cette partition des actions contrôlables du processus vis-à-vis de
l’équité sera nécessaire pour résoudre le cas général.
Théorème 4.22. Le problème de SSD asynchrone équitable est décidable pour les architectures singleton, les spécifications ω-régulières, et toute partition des actions contrôlables.
La fin de cette sous-section est consacrée à la preuve de ce théorème. Soit A = ({p}, Γ, E)
une architecture singleton. On présente la démonstration pour une formule ϕ de LTL(Γ), i.e.,
dont les propositions atomiques sont les actions de Γ.
La démonstration se fait par réduction à la satisfaisabilité de CTL∗ . On peut assimiler ici
une stratégie du système à une fonction sur les mots f : Γ∗ → 2Γ telle que, pour tout α ∈ Γ∗ ,
f (α) ∩ In = In et |f (α) ∩ Out| ≤ 1. On va construire une formule de CTL∗ (Γ) dont on affirme
qu’elle est satisfaisable si et seulement si il existe une stratégie gagnante pour (A, ϕ). Cette
formule va s’interpréter sur des arbres d’exécutions selon une stratégie dont l’étiquette aura
été enrichie de deux façons : afin de déterminer si une exécution satisfait la spécification, on va
faire apparaı̂tre les actions (donc la structure de l’arbre) dans l’étiquette. Afin de déterminer
si l’arbre est bien un arbre selon une stratégie, et que l’exécution est bien équitable, on doit
également faire apparaı̂tre la valeur de la stratégie dans l’étiquette.
Pour une stratégie du système f : Γ∗ → 2Γ , on va définir behavior(f) : Γ∗ → ({ε} ∪ Γ) ×
({#}∪Out) son arbre d’exécutions enrichi. Moralement, la première composante de l’étiquette
va refléter la direction courante de l’arbre, et donc indiquer quelle a été la dernière action
jouée, tandis que la deuxième composante de l’étiquette va donner la valeur de la stratégie
sur les actions contrôlables après avoir vu l’histoire représentée par le nœud courant. Par
exemple, pour un nœud α · a ∈ Γ∗ représentant un préfixe d’une exécution f -compatible,
behavior(f)(α · a) = (a, b) avec {b} = f (α · a) ∩ Out.
Formellement, on définit
(
(ε, f (ε) ∩ Out) si f (ε) ∩ Out 6= ∅
behavior(f)(ε) =
(ε, #)
sinon.
et, pour tout α tel que behavior(f)(α) est déjà défini, pour tout a ∈ f (α),
(
(a, f (α · a) ∩ Out) si f (α · a) ∩ Out 6= ∅
behavior(f)(α · a) =
(a, #)
sinon.
Tel que l’arbre est défini, toutes les branches de behavior(f) sont infinies si In 6= ∅. Or,
lorsqu’après une histoire α ∈ Γ∗ , la stratégie ne propose aucune action contrôlable, l’exécution f -compatible finie α est f -maximale, donc f -équitable d’après la remarque 4.8, et
doit satisfaire la spécification. On veut donc que la formule de CTL∗ que l’on va construire
118
Chapitre 4. Synthèse de systèmes asynchrones
soit à même de vérifier que la branche finie α vérifie ϕ. Pour cela, il faut matérialiser
dans l’arbre cette branche finie, ce que l’on va faire artificiellement en ajoutant une direction à l’arbre behavior(f). Finalement, pour f : Γ∗ → 2Γ stratégie du système, on définit
behavior(f) : (Γ ∪ {#})∗ → ({ε, #} ∪ Γ) × ({#} ∪ Out) par
(
(ε, f (ε) ∩ Out) si f (ε) ∩ Out 6= ∅
behavior(f)(ε) =
(ε, #)
sinon.
pour tout α ∈ Γ∗ tel que behavior(f)(α) est déjà défini, pour tout a ∈ f (α),
(
(a, f (α · a) ∩ Out) si f (α · a) ∩ Out 6= ∅
behavior(f)(α · a) =
(a, #)
sinon.
et, si f (α) ∩ Out = ∅,
behavior(f)(α · #) = (#, #)
Ainsi les nœuds α ∈ Γ∗ · {#} sont des feuilles de l’arbre, matérialisant les exécutions finies
f -compatibles et f -équitables.
Exemple 4.23. Considérons une structure singleton ayant comme alphabet d’actions In =
{a, b, c, d} et Out = {A, B, C}. La stratégie f : Γ∗ → 2Γ définie par
f (α · a) = {a, b, c, d, A}
f (α · b) = {a, b, c, d, B}
f (α · c) = {a, b, c, d, C}
f (α · d) = {a, , b, c, d}
pour tout α ∈ Γ∗ est associée à l’arbre behavior(f) dont une partie est représentée figure 4.9.
Remarque 4.24. Quel que soit α ∈ Γω , exécution f -compatible, α est une branche de
behavior(f). Quel que soit α ∈ Γ∗ , exécution f -compatible et f -maximale, α · # est une
branche maximale de behavior(f). Réciproquement, toute branche α ∈ Γω de behavior(f) est
une exécution f -compatible, et toute branche maximale α ∈ Γ∗ de behavior(f) est de la forme
α = α′ · {#} avec α′ exécution f -compatible f -maximale.
Soit ϕ ∈ LTL(Γ). On définit la formule ϕ ∈ LTL(({ε, #} ∪ Γ) × (Out ∪ {#})) par récurrence
sur la structure de ϕ :
a=
_
(a, b) pour a ∈ Γ
b∈Out∪{#}
¬ϕ = ¬ϕ
ϕ∨ψ =ϕ∨ψ
X ϕ = X(ϕ ∧ ¬(#, #))
ϕ U ψ = ϕ U (ψ ∧ ¬(#, #))
119
2. Résultats de décidabilité
(ε, #)
(a, A)
(b, B)
(a, A) (b, B) (c, C)(d, #) (A, #)
(c, C)
(d, #)
(#, #)
(a, A) (b, B) (c, C)(d, #)(C, #)
(a, A) (b, B) (c, C)(d, #)(#, #)
(a, A) (b, B) (c, C)(d, #)(B, #)
Fig. 4.9 – Un arbre behavior(f)
La formule ϕ correspond à la spécification ϕ interprétée sur les branches de behavior(f).
Les transformations de X ϕ et ϕ U ψ correspondent aux exécutions finies qui finissent par
# sur les branches de behavior(f). On veut donc s’assurer que la formule est vérifiée avant
d’atteindre la feuille # artificiellement ajoutée et qui ne correspond à aucun événement de
l’exécution représentée.
Par la suite, pour tout élément (a, b) ∈ ({ε, #} × Γ) × ({#} ∪ Out), on note π1 (a, b) =
a la projection sur la première composante, et π2 (a, b) = b la projection sur la deuxième
composante. Le lemme suivant formalise le fait qu’une exécution f -compatible α satisfait ϕ
si et seulement si la branche correspondante de behavior(f) satisfait X ϕ.
Notation 4.25. Pour tout α ∈ (Γ∪{#})∞ branche maximale de behavior(f), on définit runf (α)
de la façon suivante :
(
π1 (behavior(f)(α[1])) · π1 (behavior(f)(α[2])) · · · si α ∈ Γω
runf (α) =
π1 (behavior(f)(α[1])) · · · π1 (behavior(f)(α[n]))
si α ∈ Γn · {#}
En fait, runf (α) = α si α ∈ Γω et runf (α · #) = α si α ∈ Γ∗ .
Lemme 4.26. Pour tout f : Γ∗ → 2Γ stratégie du système, pour tout α ∈ (Γ∪{#})∞ branche
maximale de behavior(f), on a behavior(f), α, 0 |= X ϕ si et seulement si runf (α), 0 |= ϕ.
Démonstration.
La modalité X apparaı̂t dans la réduction car dans le cas de formules de
CTL∗ , donc interprétée sur les arbres, l’étiquette de la racine est la lettre initiale, tandis que
dans notre réduction, elle ne représente pas la première action d’une exécution. Pour rendre
ceci évident, on constate que X ϕ est en fait une formule de LTL(({ε, #} ∪ Γ) × ({#} × Out)),
et on identifie (behavior(f), α) au modèle de LTL u : N|α| → ({ε, #} ∪ Γ) × ({#} ∪ Out) tel
que, pour tout i ∈ N|α| , u(i) = behavior(f)(α[i]). On rappelle (voir section 1.2.2 page 14) que
120
Chapitre 4. Synthèse de systèmes asynchrones
Nω = N et pour tout n ∈ N, Nn = {0, 1 . . . , n}. Il est clair que pour tout i ∈ N|α| , pour tout
ϕ ∈ LTL(({ε, #} ∪ Γ) × ({#} ∪ Out)), behavior(f), α, i |= ϕ si et seulement si u, i |= ϕ.
On identifie également runf (α) à l’application v : {i ∈ N | 0 ≤ i < |runf (α)|} → Γ en
posant, pour tout 0 ≤ i < |runf (α)| = |v|, v(i) = π1 (behavior(f)(α[i + 1])) = π1 (u(i + 1)).
On remarque que si α est fini et tel que |α| = n + 1, alors |u| = n + 2 et |v| = n ; si α est
infini, |α| = |u| = |v| = ω. Ceci nous permet de montrer par récurrence sur la structure de
ϕ ∈ LTL(Γ), que pour tout 0 ≤ i < |runf (α)|, u, i + 1 |= ϕ si et seulement si v, i |= ϕ.
Le cas où ϕ = a ∈ Γ découle directement des définitions. Les cas de combinaisons booléennes sont triviaux.
Supposons maintenant que u, i + 1 |= X ϕ. Alors, i + 2 ∈ N|α| et u, i + 2 |= ϕ et u, i + 2 |=
¬(#, #), donc i + 1 < |runf (α)| = |v|. En appliquant l’hypothèse de récurrence, on obtient
donc que v, i + 1 |= ϕ donc v, i |= X ϕ. Réciproquement, si v, i |= X ϕ alors i + 1 < |v|
donc i + 3 < |u|, et v, i + 1 |= ϕ. Par définition, on en déduit que u(i + 2) 6= (#, #) (car
(#, #) étiquette les feuilles de behavior(f)), et par hypothèse de récurrence on a également
que u, i + 2 |= ϕ. Donc u, i + 1 |= X ϕ.
Enfin, si u, i + 1 |= ϕ U ψ alors il existe j, tel que i + 1 ≤ j + 1 < |u| et tel que u, j + 1 |=
ψ ∧ ¬(#, #) et pour tout i + 1 ≤ k + 1 < j + 1, u, k + 1 |= ϕ. Comme u, j + 1 |= ¬(#, #), alors
j + 2 < |u| et donc j < |v|. Par hypothèse de récurrence, on a v, j |= ψ et pour tout i ≤ k < j,
v, k |= ϕ. Réciproquement, si v, i |= ϕ U ψ, alors il existe i ≤ j < |v| tel que v, j |= ψ et pour
tout i ≤ k < j, on a v, k |= ϕ. Comme j < |v|, alors j + 2 < |u|, et donc u, j + 1 |= ¬(#, #),
et par hypothèse de récurrence, on a u, j + 1 |= ψ et pour tout i + 1 ≤ k + 1 < j + 1, on a
u, k + 1 |= ϕ, donc u, i + 1 |= ϕ U ψ.
On affirme qu’une stratégie f est gagnante pour (A, ϕ) et une partition P des actions
contrôlables Out si et seulement si behavior(f) est un modèle de la formule de CTL∗ (({ε, #} ∪
Γ) × (Out ∪ {#})) suivante
avec
ϕ
e = AG Compat ∧ AG Complet ∧ A(Fair → X ϕ) ∧ ε1
Compat = #1 → (#2 ∧ ¬ X ⊤)
^
Complet = ¬#1 → (
EX a1 ∧
Fair =
^
Σ′ ∈P
a∈In
(FG(
_
b∈Σ′
_
(b2 ∧ EX b1 ))
b∈Out∪{#}
b2 ) → (GX ⊤ ∧ GF
_
b1 ))
b∈Σ′
W
où, pour
tout
a
∈
{ε,
#}
∪
Γ,
la
formule
a
=
1
b∈(Out∪{#}) (a, b) et, pour tout b ∈ {#} ∪ Out,
W
b2 = a∈{ε,#}∪Γ (a, b).
La sous-formule Compat assure qu’un nœud étiqueté par # sur sa première composante
est bien une feuille de l’arbre considéré, alors que Complet vérifie que tout nœud étiqueté par
{ε} ∪ Γ sur sa première composante a au moins |In| + 1 fils, un pour chaque entrée possible,
et un pour l’action contrôlable choisie par la stratégie (ou # si la stratégie ne propose aucune
action contrôlable). Avec la sous-formule Complet on s’assure donc que toutes les exécutions f compatibles apparaissent dans l’arbre. Enfin, Fair est une formule sur les chemins vérifiant que
l’exécution est équitable. On remarque que les chemins finis f -maximaux satisfont trivialement
Fair car violent la prémisse de l’implication : dans l’arbre behavior(f) ces chemins se finissent
121
2. Résultats de décidabilité
par # ∈
/ Σ. La clause ε1 est ajoutée pour des simplifications techniques, et pourrait être
supprimée. Elle vise à s’assurer que tous les modèles de ϕ
e ont la même valeur sur la première
composante de l’étiquette de la racine.
À présent, on fixe la partition P en fonction de laquelle l’équité est assurée, et on dit
qu’une stratégie f : Γ∗ → 2Γ est gagnante pour (A, ϕ) si toutes ses exécutions f -équitables
vis-à-vis de P (voir la définition 4.7 donc) satisfont ϕ.
Proposition 4.27. Soit f : Γ∗ → 2Γ une stratégie du système gagnante pour (A, ϕ), avec
ϕ ∈ LTL(Γ). Alors behavior(f) |= ϕ.
e
Démonstration.
– Soit α ∈ Γω ∪ Γ∗ · {#} une branche maximale de behavior(f) et
soit i ∈ N|α| . Supposons que π1 (behavior(f)(α[i])) = #. Alors par définition, α[i] est une
feuille de behavior(f) et behavior(f)(α[i]) = (#, #). Donc behavior(f) |= AG Compat.
– Soit α ∈ Γω ∪ Γ∗ · {#} une branche maximale de behavior(f) et soit i ∈ N|α| . Si
π1 (behavior(f)(α[i])) 6= #, alors α[i] ∈ Γ∗ ∩ dom(behavior(f)) et, par définition, pour
tout a ∈ f (α[i]), π1 (behavior(f)(α[i] · a)) = a. En particulier, pour tout a ∈ In, il existe
α′ ∈ Γω ∪ Γ∗ · {#} tel que α′ [1] = a et α[i] · α′ est une branche maximale de behavior(f).
Alors behavior(f), α[i]α′ , i + 1 |= a1 . De même, soit b = π2 (behavior(f)(α[i])) ∈ Out ∪
{#}, alors par définition, behavior(f), α, i |= EX b1 . Donc behavior(f) |= AG Complet.
– Soit α ∈ Γω ∪Γ∗ ·{#} une branche maximale de behavior(f) telle que behavior(f), α, 0 |=
Fair. Si α ∈ Γ∗ · {#}, alors runf (α) est f -maximal, donc équitable. Dans ce cas,
runf (α) |= ϕ, et par le lemme 4.26, behavior(f), α |= X ϕ. Supposons maintenant
que α ∈ Γω . Soit Σ′ ∈ P et i ∈ N|α| vérifiant, pour tout j ∈ N|α| , si j ≥ i, alors
π2 (behavior(f)(α[j])) ∈ Σ′ . Pour tout i ∈ N|α| , il existe alors j ≥ i tel que la projection
π1 (behavior(f)(α[j])) ∈ Σ′ . On en déduit donc que l’exécution α est f -équitable pour la
partition considérée et, comme f est une stratégie gagnante pour (A, ϕ), on a α |= ϕ.
Comme runf (α) = α, le lemme 4.26 permet de conclure que behavior(f), α |= X ϕ. Donc
behavior(f) |= A(Fair → X ϕ).
– Par construction, behavior(f) |= ε1 .
Donc behavior(f) |= ϕ.
e
Proposition 4.28. Si ϕ
e a un modèle, alors il existe une stratégie gagnante pour (A, ϕ).
Démonstration.
Soit D un domaine fini et t : D ∗ → ({ε, #}∪Γ)×({#}∪Out) un modèle
de ϕ.
e On montre qu’on peut alors obtenir un autre modèle de ϕ
e dont l’ensemble des directions
est exactement {#} ∪ Γ. Pour cela on définit par récurrence une fonction Φ : ({#} ∪ Γ)∗ → D ∗
telle que si α ∈ dom(Φ) alors Φ(α) ∈ dom(t) :
Φ(ε) = ε,
et, pour tout α ∈ Γ∗ tel que Φ(α) est déjà défini, pour tout a ∈ In ∪ π2 (t(Φ(α))),
Φ(α · a) = Φ(α) · d
avec d ∈ D tel que π1 (t(Φ(α) · d)) = a (un tel d existe car t |= AG Complet).
Pour tout a ∈ (Out ∪ {#}) \ {π2 (t(Φ(α)))}, Φ(α · a) n’est pas défini. Donc les seuls cas où
α · # ∈ dom(Φ) correspondent aux cas où π2 (t(Φ(α)) = #.
On définit maintenant l’arbre t′ : (Γ ∪ {#})∗ → ({ε, #} ∪ Γ) × ({#} ∪ Out) de la façon
suivante : pour tout α ∈ dom(Φ),
t′ (α) = t(Φ(α)).
122
Chapitre 4. Synthèse de systèmes asynchrones
.
L’arbre t′ est donc isomorphe à un sous-arbre de t, et vérifie par construction, pour tout
α ∈ Γ∗ et tout a ∈ Γ ∪ {#} tels que α · a ∈ dom(t′ ), π1 (t′ (α · a)) = a.
F On étend′ Φ aux mots
ω
′
infinis en posant, pour tout α ∈ Γ branche maximale de t , Φ(α) = α′ ⊑α Φ(α ).
Remarque 4.29. Pour tout α ∈ (Γ ∪ {#})∞ branche maximale de t′ , Φ(α) est une branche
maximale de t, et de plus, |α| = |Φ(α)|.
Ceci découle du fait que, comme t |= AG Compat, pour tout ρ ∈ D∗ tel que π1 (t(ρ)) = #,
ρ est une branche maximale de t.
De plus, en appliquant les définitions, on obtient immédiatement que
Remarque 4.30. Pour tout α ∈ (Γ ∪ {#})∞ branche maximale de t′ , pour tout i ∈ N|α| , pour
tout ψ ∈ LTL(({ε, #} ∪ Γ) × ({#} ∪ Out)), on a t′ , α, i |= ψ si et seulement si t, Φ(α), i |= ψ.
On définit à présent f : Γ∗ → 2Γ stratégie du système en posant, pour tout α ∈ Γ∗ ,
f (α) ∩ In = In
f (α) ∩ Out = {π2 (t′ (α))} si α ∈ dom(t′ ) et π2 (t′ (α)) 6= #.
Pour montrer que f est une stratégie gagnante, il reste à montrer que t′ |= ϕ
e et que
behavior(f) = t′ . En effet, si tel est le cas, alors soit α ∈ Γω une exécution f -compatible
et f -équitable. Dans ce cas, comme on l’a vu dans la remarque 4.24, α est une branche
de behavior(f). De plus, behavior(f), α, 0 |= Fair. Donc comme behavior(f) = t′ |= ϕ,
e alors
behavior(f), α, 0 |= X ϕ et, par le lemme 4.26, runf (α) = α |= ϕ. Soit maintenant α ∈ Γ∗ une
exécution f -compatible et f -maximale. Elle est donc f -équitable. Comme mentionné dans la
remarque 4.24, α · {#} est une branche maximale de behavior(f), et behavior(f), α · {#}, 0 |=
Fair. Donc, une fois de plus, en utilisant le fait que t′ = behavior(f), que t′ |= ϕ
e et le
lemme 4.26, on obtient que runf (α · {#}) = α |= ϕ. Donc, toute exécution f -compatible et
f -équitable satisfaisant la spécification, on en déduit que f est une stratégie gagnante pour
(A, ϕ).
Montrons à présent que t′ |= ϕ
e:
∞
– Soit α ∈ ({#} ∪ Γ) une branche maximale de t′ , et soit i ∈ N|α| . Si t′ , α, i |= #1 ,
alors π1 (t′ (α[i])) = π1 (t(Φ(α[i]))) = #. Soit ρ ∈ D∞ une branche maximale de t telle
que ρ[i] = Φ(α[i]). Alors t, ρ, i |= #1 et, comme t |= ϕ,
e alors t, ρ, i |= #2 . Donc, par
′
′
∗
définition de t , on a t , α, i |= #2 . De plus, α[i] ∈ Γ · {#}, donc pour tout a ∈ Γ ∪ {#},
α[i] · a ∈
/ dom(Φ), donc α[i] · a ∈
/ dom(t′ ), et t′ , α, i |= ¬ X ⊤. Ainsi, t′ |= AG Compat.
– Soit α ∈ ({#}∪Γ)∞ une branche maximale de t′ , et soit i ∈ N|α| . Si t′ , α, i |= ¬#1 , on en
′
déduit que α[i] ∈ Γ∗ et, par définition
V de Φ et de t , pour tout a ∈ In, α[i]·a ∈′ dom(Φ) et
′
′
π1 (t (α[i]·a)) = a. Donc t , α, i |= a∈In EX a. Soit b ∈ Out∪{#} tel que π2 (t (α[i])) = b.
Alors parWdéfinition, π2 (t(Φ(α[i]))) = b, α[i] · b ∈ dom(Φ) et π1 (t′ (α[i] · b)) = b. Donc
t′ , α, i |= b∈Out∪{#} (b2 ∧ EX b1 ), et t′ |= AG Complet.
– Soit α ∈ ({#} ∪ Γ)∞ une branche maximale de t′ telle que t′ , α, 0 |= Fair, alors, d’après
e alors t, Φ(α), 0 |= X ϕ et, à nouveau
la remarque 4.30, t, Φ(α), 0 |= Fair. Comme t |= ϕ,
par la remarque 4.30, on a t′ , α, 0 |= X ϕ.
Montrons enfin que t′ = behavior(f) : on va montrer par récurrence sur la taille de α ∈
(Γ ∪ {#})∗ que t′ (α) = behavior(f)(α).
123
2. Résultats de décidabilité
(
(ε, b)
behavior(f)(ε) =
(ε, #)
si f (ε) ∩ Out = {b}
si f (ε) ∩ Out = ∅.
= t′ (ε).
Soit α ∈ dom(behavior(f)). Alors, par hypothèse de récurrence, α ∈ dom(t′ ) et t′ (α) =
behavior(f)(α). Par définition de f , f (α) = In ∪ {π2 (t′ (α))} \ {#}. Soit a ∈ f (α). Alors
(
(a, b)
behavior(f)(α · a) =
(a, #)
si f (α · a) ∩ Out = {b}
si f (α · a) ∩ Out = ∅.
= (a, π2 (t′ (α · a)))
= t′ (α · a).
Si f (α) ∩ Out = ∅, alors π2 (t′ (α)) = π2 (t(Φ(α)) = # et
behavior(f)(α · #) = (#, #)
= t′ (α · #).
De même, si α ∈ dom(t′ ) alors par hypothèse de récurrence, α ∈ dom(behavior(f)) et t′ (α) =
behavior(f)(α). Soit a ∈ {#} ∪ Γ tel que α · a ∈ dom(t′ ). Alors a ∈ In ∪ π2 (t′ (α)), et il est clair
que α · a ∈ dom(behavior(f)) et que t′ (α · a) = behavior(f)(α · a).
On a donc donné une réduction polynomiale du problème de SSD asynchrone équitable
pour les architectures singleton et les spécifications de LTL(Γ) au problème de satisfaisabilité
de CTL∗ , ce qui nous permet de conclure que la complexité du problème est 2EXPTIME, car
la satisfaisabilité de CTL∗ est un problème 2EXPTIME-complet ([VS85, EJ99]). De plus, s’il
existe un modèle de ϕ
e alors il existe un modèle représentant une stratégie à mémoire finie
(i.e., calculable par un automate fini).
On peut montrer que cette complexité est également une borne inférieure :
Proposition 4.31. Le problème de SSD asynchrone équitable pour les architectures singleton
et les spécifications de LTL(Γ) est 2EXPTIME-complet.
Démonstration.
On a déjà montré que le problème est dans 2EXPTIME. La démonstration de la 2EXPTIME-difficulté se fait par réduction du problème de synthèse de système
centralisé synchrone sans délai de [PR89a], qui est 2EXPTIME-complet pour les spécifications
LTL (voir théorème 2.31 page 32).
On a montré au début du chapitre précédent (section 1 page 52) que les données du problème de synthèse synchrone tel que présenté dans la définition 2.29 page 31 pouvaient être
présentées de façon simplifiée. Soit donc A = (Proc, V, E, (S v )v∈V , s0 , (dp )p∈Proc ) une architecture à synthétiser, telle que Proc = {p}, et dp = 0, et soit ϕ ∈ LTL(V ) une spécification. On va
construire une architecture singleton A′ = (Proc, Γ, E ′ ) et une spécification ϕ′ ∈ LTL(Γ) tels
qu’il existe une stratégie f : (S VI )+ → S VO gagnante pour (A, ϕ) si et seulement si il existe
une stratégie f ′ : Γ∗ → 2Γ gagnante pour (A′ , ϕ′ ) et la partition la plus grossière P = Out.
124
Chapitre 4. Synthèse de systèmes asynchrones
Afin d’avoir à modifier le moins possible la spécification au cours de la réduction, on va
prendre comme actions externes de l’architecture A′ simplement les valeurs des variables.
Formellement, on a
Proc = {p}
In = S VI
Out = S VO
E = (Γ × Proc) ∪ (Proc × Γ)
owner(a) = {p} pour tout a ∈ Out.
Une action de l’environnement est simplement la valeur qu’il décide de donner aux variables
d’entrée, et une action du processus correspond à la valeur qu’il décide de donner aux variables
de sortie.
Par ailleurs, la spécification ϕ porte sur les valeurs des états du système de transition T SA
associé à A. Les propositions atomiques sont donc des éléments de S V . La spécification ϕ′
restreignant les comportements de l’architecture A′ porte sur les mots de Γ∞ . Les propositions
atomiques sont donc des éléments de S VI ∪S VO . De plus, les exécutions de A′ que l’on cherche à
obtenir doivent simuler les exécutions synchrones de A. Elles doivent donc être une alternance
stricte d’actions de l’environnement et d’actions du système. Par ailleurs, elles doivent être
infinies ; la stratégie du système A′ doit donc être toujours définie, sous peine de voir une
exécution maximale finie, qui ne serait pas une exécution du système synchrone correspondant.
On définit donc la spécification ϕ′ ∈ LTL(Γ) suivante
ϕ′ = GX ⊤ ∧ (sV0 I ∧ (G(In → X Out)) ∧ (G(Out → X In))) → (X sV0 O ∧ ϕ))
où ϕ est défini par
s = sVI ∧ X sVO si s ∈ S V
¬ϕ = ¬ϕ
ϕ∨ψ =ϕ∨ψ
X ϕ = X(X ϕ)
ϕ U ψ = (In → ϕ) U (In ∧ ψ)
def
et In =
W
a∈In a,
def
et Out =
W
a∈Out
a.
Remarque 4.32. Pour toutes séquences σ = s0 s1 · · · ∈ (S V )ω et α′ = a′0 a′1 · · · ∈ Γω vérifiant
pour tout i ≥ 0, sVi I = a′2i et sVi O = a′2i+1 , alors, pour tout i ≥ 0, pour tout ϕ ∈ LTL(V ), on a
σ, i |= ϕ si et seulement si α′ , 2i |= ϕ.
En effet, soit i ≥ 0, et s ∈ S V , alors σ, i |= s si et seulement si si = s si et seulement si
= sVI et a′2i+1 = sVO , si et seulement si α′ , 2i |= sVI ∧ X sVO . Les cas où ϕ est construit
à partir de combinaisons booléennes sont triviaux. Si σ, i |= X ϕ alors σ, i + 1 |= ϕ et par
hypothèse de récurrence α′ , 2i + 2 |= ϕ et α′ , 2i |= X(X ϕ). Réciproquement, si α′ , 2i |= X(X ϕ),
alors par définition α′ , 2i + 2 |= ϕ et par hypothèse de récurrence σ, i + 1 |= ϕ donc σ, i |= X ϕ.
Enfin, si σ, i |= ϕ U ψ, alors il existe j ≥ i tel que σ, j |= ψ et pour tout i ≤ k < j on a
σ, k |= ϕ. Par hypothèse de récurrence, ceci implique que α′ , 2j |= ψ et pour tout i ≤ k < j on
a α′ , 2k |= ϕ. Par construction, a′2j ∈ In, donc α′ , 2j |= In ∧ ψ, et pour tout i ≤ k < j, a′2k ∈ In
a′2i
125
2. Résultats de décidabilité
/ In. Alors, pour tout 2i ≤ k < 2j, on a α′ , k |= In → ϕ. Donc α′ , 2i |= ϕ U ψ.
et a′2k+1 ∈
Réciproquement, si α′ , 2i |= ϕ U ψ, alors il existe j ≥ 2i tel que α′ , j |= In ∧ ψ et pour tout
2i ≤ k < j, α′ , k |= In → ϕ. Par définition de α′ , si α′ , j |= In alors il existe j ′ ≥ i tel que
j = 2j ′ et l’hypothèse de récurrence permet de conclure que σ, j ′ |= ψ. De même, pour tout
2i ≤ k < j, si α′ , k |= In alors il existe k′ tel que k = 2k′ . Comme par ailleurs, α′ , k |= ϕ, une
fois de plus, l’hypothèse de récurrence permet de conclure que σ, k′ |= ϕ, et α, i |= ϕ U ψ.
Soit f : (S VI )+ → S VO une stratégie gagnante pour (A, ϕ). On construit f ′ : Γ∗ → 2Γ en
posant, pour tout α ∈ Γ∗ , pour tous a, a0 , a1 ∈ Γ,
f ′ (ε) = f ′ (a) = S VI ∪ {sV0 O }
(
S VI ∪ {f (πIn (α))}
f ′ (a0 · a1 · α) =
S VI ∪ {sV0 O }
si α ∈ (In · Out)∗ · In et a0 = sV0 I et a1 = sV0 O
sinon.
Soit α′ = a′0 a′1 · · · ∈ Γ∞ une exécution f ′ -compatible et f ′ -équitable pour P. Alors, comme
pour tout α ∈ Γ∗ fini, f ′ (α) ∩ Out 6= ∅, une exécution finie ne peut pas être f -maximale, donc
α′ ∈ Γω et α′ |= G X ⊤. Supposons que α′ |= (sV0 I ∧ (G(In → X Out)) ∧ (G(Out → X In))). Alors
α′ ∈ (In·Out)ω et, par définition de f ′ , a′1 = sV0 O et, pour tout i ≥ 1, a′2i+1 = f (πIn (a′2 · · · a′2i )).
On construit σ = s0 s1 · · · ∈ (S V )ω défini par sVi I = a′2i et sVi O = a′2i+1 , pour tout i ≥ 0.
Par construction, σ est une exécution f -compatible. Comme f est gagnante pour (A, ϕ),
alors σ |= ϕ et, par la remarque 4.32, on a α′ |= ϕ. Donc, pour tout α′ ∈ Γ∞ , exécution f ′ compatible et f ′ -équitable, on sait que α′ satisfait ϕ′ et on en conclut que f ′ est une stratégie
gagnante pour (A′ , ϕ′ ).
Réciproquement, soit f ′ : Γ∗ → 2Γ une stratégie gagnante pour (A′ , ϕ′ ). Alors pour tout
α′ ∈ Γ∗ exécution f ′ -compatible, f ′ (α′ ) ∩ Out 6= ∅ (sinon α′ est une exécution f ′ -maximale,
et α′ 6|= G X ⊤, ce qui est impossible car f ′ est une stratégie gagnante). On définit alors
′
∈ Γ+ , où
f : (S VI )+ → S VO . Pour tout ρ = r1 · · · rn ∈ (S VI )+ , on pose ρ′ = r0′ r1′ · · · r2n
′ ′ ′
′
′ = r et r ′
r0′ = sV0 I , r1′ = sV0 O , et, pour tout i > 0, r2i
i
2i+1 = s avec {s} = f (r0 r1 · · · r2i ) ∩ Out.
+
V
Alors on définit, pour tout ρ ∈ (S I ) ,
f (ρ) = s avec f ′ (ρ′ ) ∩ Out = {s}
Soit σ = s0 s1 · · · ∈ (S V )ω une exécution f -compatible. On définit α′ = a′0 a′1 · · · ∈ (Γ)ω
par a′2i = (si )VI et a′2i+1 = (si )VO , pour tout i ≥ 0. On remarque que si ρ = (s1 · · · si )VI
alors ρ′ = a′0 a′1 · · · a′2i . Par définition de f et d’une exécution synchrone, pour tout i ≥ 1,
a′2i+1 = sVi O = f ((s1 · · · si )VI ) ∈ f ′ (a′0 · · · a′2i ) ∩ Out, donc α′ est une exécution f ′ -compatible.
Par construction, le nombre d’actions contrôlables de α′ est infini, donc cette exécution est
trivialement f ′ -équitable. Comme f ′ est une stratégie gagnante, on en conclut que α′ |=
(sV0 I ∧(G(In → X Out))∧(G(Out → X In))) → (X sV0 O ∧ϕ). Par construction, α′ |= sV0 I ∧(G(In →
X Out)) ∧ (G(Out → X In)), donc α′ |= ϕ, et par la remarque 4.32, σ |= ϕ. Donc f est bien
une stratégie gagnante pour (A, ϕ).
Remarque 4.33. Afin d’obtenir la décidabilité du problème de SSD asynchrone équitable pour
les architectures singleton et les spécifications ω-régulières, on aurait également pu adapter la
démonstration de [Var95] à notre modèle. On rappelle que [Var95] propose une démonstration
de la décidabilité du problème de synthèse équitable de systèmes centralisés asynchrones à
communication par variables partagées basée sur des constructions d’automates (voir théorème 2.50 page 41). Ce problème est également 2EXPTIME-complet lorsque la spécification
126
Chapitre 4. Synthèse de systèmes asynchrones
est donnée par un automate de Büchi. Par ailleurs, [Var95] fait remarquer que bien qu’on pourrait naı̈vement penser qu’une spécification LTL entraı̂nerait une complexité dans 3EXPTIME
par cette méthode (la transformation d’une formule LTL en un automate de Büchi ayant un
coût exponentiel), on peut en fait obtenir une complexité doublement exponentielle même en
partant d’une formule LTL, en construisant judicieusement les automates de la démonstration.
2.2
Les architectures fortement connexes
Dans cette section on étend la décidabilité du problème de SSD asynchrone équitable à
toute la sous-classe des structures fortement connexes. La démonstration se fait par réduction
à la synthèse du singleton. Formellement, on va montrer le résultat suivant :
Théorème 4.34. Le problème de SSD asynchrone équitable est décidable pour les structures
fortement connexes avec des spécifications AlocTL.
Soient S = (Proc, R, (Inp )p∈Proc , (Outp )p∈Proc ) une structure fortement connexe et ϕ ∈
AlocTL(Proc, Γ) la spécification.
On définit une structure singleton S = ({p}, R, Inp , Outp ) formée des signaux d’entrée
Inp = In et Outp = Out. On montre que le problème de SSD asynchrone équitable de la
définition 4.13 (donc avec équité locale forte) pour (S, ϕ) se réduit au problème de SSD
asynchrone équitable pour (S, ϕ), et la partition des actions contrôlables P = {Outp | p ∈
Proc}, problème dont on sait par le théorème 4.22 qu’il est décidable. On rappelle qu’une
exécution f -équitable pour l’équité locale forte du singleton S est – en adaptant la définition
aux mots – un mot α ∈ Γ∞ tel que, s’il existe un préfixe α′ ⊑ α tel que pour tout préfixe
α′′ ∈ Γ∗ tel que α′ ⊑ α′′ ⊑ α (avec ⊑ l’ordre préfixe sur les mots), on a f (α′′ ) ∩ Out 6= ∅,
alors πOut (α) ∈ Γω . Or, on va se réduire au problème de synthèse équitable dans lequel une
exécution f -équitable du singleton est telle que, pour tout p ∈ Proc, s’il existe un préfixe
α′ ∈ Γ∗ tel que pour tout préfixe α′′ ∈ Γ∗ vérifiant α′ ⊑ α′′ ⊑ α, f (α′′ ) ∩ Outp 6= ∅, alors
πOutp (α) ∈ Γω (voir la définition 4.7).
Comme toute formule ϕ ∈ AlocTL est close par extension d’ordre, si ϕ est satisfaisable, elle
est satisfaisable par des ordres totaux. On remarque que la formule ϕ dépend de l’ensemble
de processus Proc de la structure S. Lorsqu’elle est interprétée sur la structure singleton,
les modalités indexées par Proc n’ont a priori pas de sens. Cependant, comme on garde la
partition de l’alphabet Γ en fonction des processus de Proc, la sémantique donnée page 113
s’interprète parfaitement sur les ordres totaux étiquetés par Γ qui sont les exécutions du
singleton. De plus, il est clair que cette logique est un fragment de FO, les spécifications
données sont donc régulières.
On démontre à présent la réduction proprement dite. Tout d’abord on montre comment
on peut simuler une stratégie distribuée sur une structure singleton. Afin d’y parvenir, le
processus de la structure singleton doit intercaler entre les signaux externes qu’il émet et
reçoit les signaux de communication éventuellement échangés entre les processus de la structure distribuée, en respectant la condition d’équité. Ainsi, il peut reconstruire une exécution
équitable respectant la stratégie distribuée. On établit donc la proposition suivante :
Proposition 4.35. S’il existe un ensemble d’alphabets de communication et une stratégie
distribuée gagnante pour (S, ϕ), alors il existe une stratégie gagnante pour (S, ϕ) et la partition
P = {Outp | p ∈ Proc} des actions externes de S.
127
2. Résultats de décidabilité
Démonstration.
Comme dans la démonstration du théorème 4.22, on remarque que l’alphabet de dépendance (Γ, D) associé à la structure singleton S défini par a D b pour tout
a, b ∈ Γ (voir la relation (2.1) page 20) n’induit que des exécutions qui sont des ordres totaux,
et on va représenter les exécutions de S par des mots de Γ∞ .
Pour une stratégie f : Γ∗ → 2Γ , une exécution f -compatible du singleton est donc un mot
σ = s0 s1 · · · ∈ Γ∞ tel que, pour tout 0 ≤ i < |σ|, si ∈ f (σ[i]) (on rappelle que σ[0] = ε et que
pour tout i ≥ |σ|, σ[i] = σ[|σ|] = σ).
On rappelle par ailleurs qu’on peut associer à tout mot σ ∈ Σ∞ la trace de Mazurkiewicz
correspondante [σ] ∈ R(Σ, D).
Soient (Σp,q )(p,q)∈R les alphabets de communications internes utilisés induisant l’architecture distribuée A = (Proc, Σ, E), et F = (f p )p∈Proc une stratégie distribuée gagnante pour
(A, ϕ). Par la suite on considérera que les processus de Proc sont tous ordonnés par un ordre ≤
quelconque. Afin de définir une stratégie pour le singleton S, on doit tout d’abord transformer
une histoire sur Γ∗ (l’histoire disponible pour le singleton) en une histoire incluant les communications ayant éventuellement eu lieu entre les processus, de telle sorte que le singleton soit
à même de simuler le comportement des différents processus de S. De plus le singleton doit
simuler un ordonnancement équitable des actions internes des différents processus. Pour cela
on va maintenir une file de priorités. On va donc définir Φ : Γ∗ → Σ∗ une fonction qui enrichit
l’histoire sur le singleton en une histoire sur l’alphabet complet, l’application rg(f p ) : Σ∗ → N
pour tout p ∈ Proc, qui représente la priorité associée au processus p après une histoire sur
Σ∗ , et enfin la stratégie du singleton f : Γ∗ → 2Γ .
Pour tout p ∈ Proc, pour tout σ ∈ Σ∗ et pour tout s ∈ Σ, on définit donc
rg(f p )(ε) = 0

p

rg(f )(σ) + 1
rg(f p )(σs) = 1


0
si s 6= f p ([σ]) et f p ([σs]) est définie
si s = f p ([σ]) et f p ([σs]) est définie
sinon.
Le rang d’un processus de Proc dans la file de priorités augmente donc strictement tant que
sa stratégie est définie sans qu’il puisse jouer. Par ailleurs, un processus dont la stratégie est
définie a toujours un rang strictement supérieur dans la file de priorités au rang d’un processus
dont la stratégie n’est pas définie.
Notation 4.36. Pour tout σ ∈ Σ∗ , on définit proc(σ) = min{p ∈ Proc | rg(f p )(σ) =
maxq∈Proc (rg(f q )(σ))}, le processus minimal parmi ceux ayant la plus haute priorité. C’est
ce processus que le singleton va simuler après avoir vu l’histoire σ. Avec la définition de rg
qu’on a donnée, le singleton n’essaiera donc pas de simuler un processus ne désirant pas jouer
s’il existe d’autres processus pour lesquels la stratégie est définie.
La stratégie distribuée F étant déterministe, pour tout σ ∈ Σ∗ , il existe une unique
séquence maximale u = u1 · · · ∈ (Σ \ Γ)∞ vérifiant
pour tout i, ui = f p ([σ · u[i − 1]]) ∈ (ΣpC \ Γ)
(4.2)
avec p = proc(σ · u[i − 1]). La séquence u est finie si à un certain point tous les processus
ont une priorité 0, et donc si la stratégie du processus minimal n’est pas définie, ou si le
processus en tête de la file de priorités veut envoyer un signal externe.
128
Chapitre 4. Synthèse de systèmes asynchrones
Pour définir Φ on va utiliser la fonction intermédiaire Com : Σ∗ → (Σ \ Γ)∗ qui indique
quelles actions de communication insérer dans l’histoire vue sur le singleton : pour σ ∈ Σ∗ ,
(
u
si u ∈ (Σ \ Γ)∗ est la séquence maximale vérifiant l’égalité (4.2) pour σ
Com(σ) =
u[1] si u ∈ (Σ \ Γ)ω est la séquence maximale vérifiant l’égalité (4.2) pour σ
La fonction Com insère dans l’histoire du singleton autant de messages de communication
entre les processus que possible. Si la séquence maximale u vérifiant (4.2) est finie, toutes
les communications sont insérées. Sinon, i.e., si les stratégies des processus sont d’envoyer
indéfiniment des signaux de communication interne si l’environnement n’émet aucun signal,
alors on en insère uniquement un nombre fini (ici, juste le premier signal).
Après une séquence d’actions de Γ, le singleton décide de quelle action dans Out jouer
en insérant dans son passé les actions de communication entre les processus que lui dicte
la fonction Com. Puis, en fonction de cette histoire sur Σ∗ reconstruite, il propose l’action
conseillée par la stratégie du processus en tête de la file de priorités après l’exécution de
M(Σ, D) correspondant à l’histoire que le singleton a recalculée : on définit donc l’exécution
distribuée correspondant à une histoire finie sur le singleton en posant, pour r ∈ Γ∗ , a ∈ Γ,
Φ(ε) = Com(ε)
Φ(r · a) = Φ(r) · a · Com(Φ(r) · a)
et la stratégie du singleton
f (r) ∩ In = In
f (r) ∩ Out = {f p ([Φ(r)])} si f p ([Φ(r)]) ∈ Out
avec p = proc(Φ(r)). Si f p ([Φ(r)]) n’est pas définie ou si f p ([Φ(r)]) ∈ Σ \ Γ, la stratégie du
singleton est uniquement f (r) = In.
Soit r = r0 r1 · · · ∈ Γ∞ uneFexécution f -compatible et f -équitable de S. Comme Φ est
croissante, la borne supérieure r′ ⊑r Φ(r ′ )Fsur les préfixes finis de r existe et est bien définie.
On pose alors, pour tout r ∈ Γ∞ , Φ(r) = r′ ⊑r Φ(r ′ ) et
(
Φ(r)
si Φ(r) ∈ Σω
σ=
Φ(r) · u avec u ∈ (Σ \ Γ)∞ séquence maximale vérifiant (4.2) pour Φ(r) sinon
Lorsque l’environnement joue infiniment souvent, r ∈ Γω et donc Φ(r) ∈ Σω . Si par contre, il
existe un moment à partir duquel aucune action n’est une action contrôlée par l’environnement, alors il se peut que le singleton ne propose plus non plus d’action à jouer. En revanche,
la séquence u représentant les communications entre les processus de S peut elle être infinie,
i.e., les processus peuvent décider de communiquer continûment si l’environnement n’effectue
aucune action. Dans ce cas de figure, Φ(r) se finit par une partie seulement de ces communications des processus, et Φ(r) peut alors ne pas être une exécution F -compatible F -maximale.
La définition de σ complète donc l’exécution en rajoutant la séquence éventuellement infinie
des communications entre les processus. On remarque que πΓ (σ) = r, et on va montrer que
[σ] ∈ R(Σ, D) est une exécution F -compatible et F -équitable sur A.
Soit α = [σ] = (X, ⊑, λ) ∈ R(Σ, D) l’exécution sur A correspondant à σ = s0 s1 · · · ∈ Σ∞ ,
avec X = {i ∈ N | 0 ≤ i < |σ|}. On montre que α est F -compatible. Soient p ∈ Proc et
129
2. Résultats de décidabilité
j ∈ λ−1 (ΣpC ). Alors, par définition de α, λ(j) = sj et, puisque r est f -compatible et par
définition de σ, sj = f p ([σ[j]]). Pour conclure, on doit montrer que πΣp ([σ[j]]) = πΣp (α⇓α j ).
En effet, si tel est le cas, la stratégie f p étant à mémoire locale, on a f p ([[σ[j]]) = f p (α⇓α j ),
donc λ(j) = f p (α⇓α j ), ce qui correspond à la définition d’une exécution F -compatible.
On note
πΣp ([σ[j]]) = (Xj , ⊑j , λ) ∈ M(Σ, D)
avec Xj = {i ∈ N | 0 ≤ i < j} ∩ λ−1 (Σp ), et ⊑j =⊑ ∩(Xj × Xj ) et
πΣp (α⇓α j ) = (Xj′ , ⊑′j , λ) ∈ M(Σ, D)
avec Xj′ = {i ∈ N | 0 ⊑ i ⊏ j} ∩ λ−1 (Σp ) et ⊑′j =⊑ ∩(Xj′ × Xj′ ).
Remarque 4.37. < ∩ (λ−1 (Σp ))2 = ⊑ ∩ (λ−1 (Σp ))2 est un ordre total.
Par définition de la relation ⊑, Xj′ ⊆ Xj . Soit i ∈ Xj . Alors i < j et i ∈ λ−1 (Σp ). Or,
j ∈ λ−1 (Σp ) donc λ(i) D λ(j) et par définition de α, i ⊏ j. Ainsi, Xj = Xj′ , et ⊑j =⊑′j . Donc
πΣp ([σ[j]]) = πΣp (α⇓α j ), et α est une exécution F -compatible.
Supposons à présent que α n’est pas F -équitable. Pour simplifier les explications et éviter
des notations fastidieuses sur les indices, on sépare les cas où σ est fini de ceux où σ est infini.
Supposons tout d’abord que Φ(r) = σ est un mot fini. Alors si α n’est pas F -équitable, il existe
un processus p ∈ Proc tel que f p ([σ]) est défini (voir la remarque 4.8). Par définition, cela
′
signifie que rg(f p )(σ) ≥ 1. Si p 6= proc(σ) alors il existe p′ = proc(σ) tel que rg(f p )(σ) ≥ 1,
′
′
et donc tel que f p ([σ]) est défini. Si f p ([σ]) ∈ Σ \ Γ, alors u n’est pas maximal, ce qui
′
contredit la définition de σ, donc nécessairement, f p ([σ]) ∈ Out et par définition de f , on a
′
′
f (r) ∩ Out = {f p ([Φ(r)])} = {f p ([σ])}, ce qui implique que r n’est pas f -maximal, donc pas
f -équitable.
Si σ ∈ Σω , on commence par démontrer certaines caractéristiques sur la gestion de la file
de priorités. Tout d’abord, on montre que s’il existe un processus continuellement activable,
mais dont les actions ne sont insérées qu’un nombre fini de fois dans σ, alors il existe un
(éventuellement autre) processus continuellement en tête de la file de priorités dont les actions
ne sont aussi insérées qu’un nombre fini de fois.
Lemme 4.38. Supposons que σ ∈ Σω . S’il existe un processus p ∈ Proc et un indice i ≥ 0,
tel que pour tout k ≥ i, rg(f p )(σ[k + 1]) > rg(f p )(σ[k]) alors il existe un processus p′ ∈ Proc
′
′
et un indice j ≥ 0, tel que pour tout k ≥ j, rg(f p )(σ[k + 1]) > rg(f p )(σ[k]) et p′ = proc(σ[k]).
S’il existe j ≥ i tel que p = proc(σ[j]) alors pour tout
Démonstration du lemme 4.38.
k ≥ j, il est clair que p = proc(σ[k]). Si par contre p 6= proc(σ[j]) pour tout j ≥ i, alors
′
cela signifie que pour tout j ≥ i, il existe p′ ∈ Proc tel que rg(f p )(σ[j]) ≥ rg(f p )(σ[j]). Or,
′
′
s’il existe un indice k ≥ i tel que rg(f p )(σ[k + 1]) ≤ rg(f p )(σ[k]) alors pour tout j ≥ k,
′
rg(f p )(σ[j]) > rg(f p )(σ[j]). Cela implique, le nombre de processus étant fini, qu’il existe
un indice j ≥ 0 et un processus p′ ∈ Proc, tel que p′ = proc(σ[j]), et, pour tout k ≥ j,
′
′
rg(f p )(σ[k + 1]) > rg(f p )(σ[k]). Donc, pour tout k ≥ j, p′ = proc(σ[k]).
On montre à présent qu’un processus restant continuellement en tête de la file de priorité
sans qu’une action qu’il propose ne soit ajoutée dans σ (c’est-à-dire, tel que la fonction rg
augmente continuellement) ne propose nécessairement que des signaux externes :
130
Chapitre 4. Synthèse de systèmes asynchrones
Lemme 4.39. Supposons que σ ∈ Σω . S’il existe un processus p ∈ Proc et un indice i ≥ 0,
tels que pour tout k ≥ i, rg(f p )(σ[k + 1]) > rg(f p )(σ[k]), et p = proc(σ[k]), alors pour tout
n > i, f p ([σ[n]]) ∈ Out.
Supposons qu’il existe m > i tel que f p ([σ[m]]) ∈ Σ\Γ
Démonstration du lemme 4.39.
(pour tout n > i, f p ([σ[n]]) est définie, sinon rg(f p )(σ[n]) = 0). Soit rm = πΓ (σ[m]). Si rm = r,
alors σ = σ[m′ ]·u, avec m′ ≤ m, σ[m′ ] ∈ {ε}∪ (Σ∗ ·Γ), et u ∈ (Σ \Γ)ω . Sinon, σ = Φ(rm )·σ ′ =
σ[m′ ]·Com(σ[m′ ])·σ ′ , avec m′ ≤ m, σ[m′ ] ∈ {ε}∪(Σ∗ ·Γ), Com(σ[m′ ]) ∈ (Σ\Γ)∗ , et σ ′ ∈ Γ·Σω .
Le seul cas où une action de communication définie pour un processus arrivant en tête
de la file de priorités n’est pas ajouté dans Com, est le cas où la séquence d’actions de
communication des processus est infinie et où on n’insère dans r que la première de ces
actions. On montre formellement qu’ici, l’action de communication de f p est nécessairement
jouée : si σ[m] = σ[m′ ], alors σ = σ[m′ ] · f p ([σ[m]]) · u′ avec u′ ∈ Σω , et rg(f p )(σ[m + 1]) ≤ 1 ≤
rg(f p )(σ[m]), ce qui est en contradiction avec l’hypothèse. Si σ[m] = σ[m′ ] · u1 , et u1 ∈ Σ \ Γ,
alors proc(σ[m′ ]) = proc(σ[m − 1]) = p car m − 1 ≥ i. Donc, par définition, u1 = f p ([σ[m′ ]]),
et rg(f p )(σ[m]) ≤ rg(f p (σ[m − 1]), ce qui est en contradiction avec l’hypothèse. Si enfin,
σ[m] = σ[m′ ] · u avec u ∈ (Σ \ Γ)+ , et |u| > 1, alors immédiatement, σ = σ[m] · b · u′ · σ ′ ,
avec u′ ∈ Σ \ Γ+ , b = f p ([σ[m]]), et σ ′ ∈ Σω , ce qui est à nouveau en contradiction avec
l’hypothèse. Donc, pour tout n > i, on a f p ([σ[n]]) ∈ Out.
Enfin, on affirme que s’il existe un moment à partir duquel un processus reste continuellement en tête de la file de priorités, en ne proposant que des actions externes, alors la stratégie
du singleton va être de proposer continuellement les actions de ce processus.
Lemme 4.40. Supposons que σ ∈ Σω . S’il existe p ∈ Proc un processus et i ≥ 0 un indice
tels que, pour tout n ≥ i, p = proc(σ[n]) et f p ([σ[n]]) ∈ Out, alors r ∈ Γω , et pour tout préfixe
r ′ de r tel que πΓ (σ[i]) ⊑ r ′ ⊑ r, on a f (r ′ ) ∩ Out = {f p ([Φ(r ′ )])}.
Supposons que r ∈ Γ∗ . Alors σ = Φ(r)·u, u ∈ (Σ\Γ)ω .
Démonstration du lemme 4.40.
Soit n ≥ max(i, |Φ(r)|), alors p = proc(σ[n]), et f p ([σ[n]]) ∈ Out, et σ = σ[n] · u′ , avec
u′ ∈ (Σ \ Γ)ω , ce qui est en contradiction avec la définition de σ.
Donc r ∈ Γω , et soit r ′ un préfixe de r tel que πΓ (σ[i]) ⊑ r ′ . Puisque r ∈ Γω , σ[i] ⊑
Φ(πΓ (σ[i])), et comme la fonction Φ est croissante, on a σ[i] ⊑ Φ(r ′ ). Donc, par hypothèse,
p = proc(Φ(r ′ )), et f p ([Φ(r ′ )]) ∈ Out. Donc, par définition de f , on en déduit que f (r ′ )∩Out =
f p ([Φ(r ′ )]).
À l’aide de ces trois lemmes, on montre que α est une exécution F -équitable si r est
f -équitable. En effet, supposons que σ = s0 s1 · · · ∈ Σω n’est pas équitable. Alors il existe
un processus p ∈ Proc et un indice i ≥ 0 tel que pour tout k ≥ i, f p ([σ[k]]) est définie et
sk ∈
/ ΣpC . Alors, pour tout k ≥ i, rg(f p )(σ[k + 1]) > rg(f p )(σ[k]). Par le lemme 4.38, il existe
′
un processus p′ ∈ Proc et un indice j ≥ 0 tel que, pour tout k ≥ j, rg(f p )(σ[k + 1]) >
′
rg(f p )(σ[k]) et p′ = proc(σ[k]). Dans ce cas-là, le lemme 4.39 assure que pour tout n > j,
′
f p ([σ[n]]) ∈ Out. Enfin le lemme 4.40 permet de conclure que r ∈ Γω , et que pour tout
préfixe r ′ de r tel que πΓ (σ[j + 1]) ⊑ r ′ ⊑ r, on a f (r ′ ) ∩ Outp′ 6= ∅. Puisque pour tout k ≥ j,
′
′
/ Outp′ , ce qui implique que r
rg(f p )(σ[k + 1]) > rg(f p )(σ[k]), alors pour tout k ≥ j, sk ∈
n’est pas f -équitable.
Donc, pour toute exécution r ∈ Γ∞ qui soit f -compatible et f -équitable pour la partition
{Outp | p ∈ Proc}, on peut construire α = [σ] ∈ R(Σ, D), exécution F -compatible et F équitable dont r est une linéarisation de la partie observable πΓ (α). Comme F est une stratégie
131
2. Résultats de décidabilité
gagnante, πΓ (α) |= ϕ. La formule ϕ est close par extension, donc r |= ϕ. Donc f est bien une
stratégie gagnante pour (S, ϕ).
On montre à présent que toute stratégie gagnante sur la structure singleton peut être
distribuée sur une architecture fortement connexe.
Proposition 4.41. S’il existe une stratégie gagnante pour (S, ϕ) et équitable pour la partition des actions externes P = {Outp | p ∈ Proc}, alors il existe un ensemble d’alphabets
de communication et une stratégie distribuée gagnante pour (S, ϕ). De plus, s’il existe une
stratégie à mémoire finie pour le singleton alors on peut construire des ensembles d’alphabets
de communication finis et une stratégie distribuée à mémoire finie pour S.
Démonstration.
Pour obtenir ce résultat, on veut simuler une exécution totalement ordonnée compatible avec la stratégie du singleton sur le système distribué donné par la structure S. Comme les actions de l’environnement sont incontrôlables, il est impossible d’obtenir
des exécutions totalement ordonnées sur l’architecture distribuée, cependant le but de la
construction est de limiter autant que possible les événements concurrents, de façon à obtenir
des exécutions qui soient des affaiblissements des exécutions du singleton. Afin d’y parvenir,
les processus de S vont simuler un passage de jeton. On va sélectionner un cycle dans le graphe
de communication, et forcer les processus à jouer de façon séquentielle dans cet anneau virtuel
– on remarque que le cycle peut ne pas être un cycle simple.
Soit f : Γ∗ → 2Γ une stratégie gagnante pour (S, ϕ). On suppose que f est donnée par un
automate déterministe avec sortie – un automate dont toutes les exécutions sont acceptantes,
et auquel on ajoute une fonction associée aux états de l’automate. On dit que la stratégie f
est à mémoire finie si l’automate qui la calcule est fini, i.e. son ensemble d’états est fini. Soit
Af = (Qf , Γ, δf , sf0 , f ) l’automate calculant f , avec
Qf l’ensemble (fini si la stratégie est à mémoire finie) d’états
δf : Qf × Γ → Qf la fonction de transition
sf0 l’état initial
f : Qf → Out la stratégie proprement dite.
On remarque que l’automate Af ne calcule en fait que f ∩ Out. On va définir, pour chaque
p
processus p ∈ Proc un automate avec sortie Ap = (Qp , Σp , δp , sp0 , f ) calculant sa stratégie f p .
Pour cela, on choisit un cycle de taille n dans l’architecture. On utilise les fonctions auxiliaires
ring et succp définies par
ring : {1, . . . , n} → Proc
L’application ring est une application surjective qui associe à chaque élément de l’anneau que
l’on cherche à simuler un processus de Proc. Elle vérifie, pour tout 1 ≤ i < n, (ring(i), ring(i+
1)) ∈ R et (ring(n), ring(1)) ∈ R. Comme on l’a déjà relevé, ring n’est pas nécessairement
bijective et il se peut qu’un processus ait plusieurs antécédents.
succp : {1, . . . , n} → {1, . . . , n}
(
min{j ∈ ring−1 (p) | j > i} si {j ∈ ring−1 (p) | j > i} =
6 ∅
succp (i) =
−1
min{j ∈ ring (p)}
sinon.
132
Chapitre 4. Synthèse de systèmes asynchrones
L’application succp associe à un antécédent du processus p le prochain élément de l’anneau
que p aura à simuler. Par exemple si le processus p a la place 2 et 5 dans le cycle, succp (2) = 5
et succp (5) = 2.
Au cours de l’exécution, les processus vont reconstruire une exécution totalement ordonnée, linéarisation de l’exécution observable qu’ils sont en train de jouer, et respectant la
stratégie du singleton. En se passant le jeton, les processus vont donc également se transmettre l’histoire courante sur le singleton – l’état courant de l’automate Af . Le processus qui
reçoit le jeton met à jour l’histoire courante, en ajoutant à la fin la séquence des événements
locaux qu’il a observés depuis le dernier passage de jeton (dans ce cas, les seuls signaux de
communication sont les passages de jetons). Lorsque la stratégie du singleton est à mémoire
finie, les processus n’ont pas à mémoriser toute l’histoire des événements qu’ils ont observé
localement (ce qui nécessiterait une mémoire non bornée), mais uniquement la fonction de
transition partielle de Af , donnant un état de Qf d’arrivée, en fonction d’un état de départ,
lorsque les événements ayant eu lieu sont ceux observés par le processus.
Pour p ∈ Proc, les états de Ap sont donc donnés par
[
[
f
Qp = (Qf )Q ×
{NTokeni } ∪ Qf ×
{Tokeni , Token′i }
i∈ring−1 (p)
i∈ring−1 (p)
où Tokeni , Token′i et NTokeni sont des drapeaux indiquant si le processus courant possède le
jeton en simulant le i-ème élément de l’anneau, auquel cas son état courant est l’état courant
de Af , ou bien s’il ne possède pas le jeton, et dans ce cas, il mémorise les événements qu’il
observe sous forme d’une fonction de transition
partielle S
de Af . Par la suite on notera Tokenp =
S
S
′
′
f
p∈Proc (Q × i∈ring−1 (p) {Tokeni , Tokeni }).
i∈ring−1 (p) {Tokeni , Tokeni } et Token =
Lorsqu’un processus p ∈ Proc ne possède pas le jeton, l’automate Ap mémorise dans
son état courant l’histoire des événements externes visibles au processus p. Comme le seul
processus habilité à émettre des signaux est celui ayant le jeton, les seuls événements externes
pouvant avoir lieu sont des signaux émis par l’environnement. Ainsi, pour tout p ∈ Proc et
f
tout i ∈ ring−1 (p), pour tout δσ ∈ (Qf )Q permettant de calculer la mémoire nécessaire à Af
après avoir vu σ ∈ In∗p , et pour tout a ∈ Inp , on pose
δp ((δσ , NTokeni ), a) = (δσ·a , NTokeni )
avec δσ·a (s) = δf (δσ (s), a).
Lorsqu’un processus p ∈ Proc possède le jeton, il se base sur la stratégie f du singleton
pour décider quels signaux émettre. Tant que la stratégie f du singleton propose de jouer une
action de Outp , sans pouvoir la jouer, la stratégie du processus p va être de proposer cette
action. Si la stratégie du singleton change, i.e., propose une action contrôlable par un autre
processus, ou n’est plus définie, alors le processus p va essayer de passer le jeton au processus
suivant. De même, une fois que p a pu effectuer une action externe, sa stratégie est de passer
le jeton. Ceci assure que le jeton n’est pas monopolisé par un seul processus, empêchant les
autres de jouer. Pour modéliser cette différence entre la volonté de jouer une action externe,
et la volonté de passer le jeton, le processus p peut être dans des états ayant deux drapeaux
différents : Tokeni et Token′i . Formellement, pour tout p ∈ Proc, i ∈ ring−1 (p), pour tout
s ∈ Qf , pour tout a ∈ Inp ∪ Outp ,
(
(δf (s, a), Tokeni )
δ ((s, Tokeni ), a) =
(δf (s, a), Token′i )
p
si a ∈ Inp et f (δf (s, a)) ∈ Outp
sinon.
(4.3)
133
2. Résultats de décidabilité
Le premier cas représente les fois où le processus n’a pas eu l’occasion de jouer, et pour
lesquels la stratégie du singleton est toujours de jouer dans la partition Outp . Le second cas
représente les fois où le processus a pu jouer, ou bien la stratégie du singleton n’est plus définie
dans la partition Outp , et donc p va passer le jeton.
À partir du moment où un processus p veut envoyer le jeton, il ne peut plus changer
d’avis : il continue à mettre à jour l’histoire du singleton, en attendant de pouvoir effectuer
son action : formellement, pour tout p ∈ Proc, tout i ∈ ring−1 (p), pour tout tout s ∈ Qf ,
δp ((s, Token′i ), a) = (δf (s, a), Token′i ) si a ∈ Inp .
Pour modéliser le passage de jeton, un processus envoie l’état courant de l’automate Af au
processus suivant dans le cycle. Pour expliciter le processus destinataire du signal, et obtenir
des ensembles d’alphabets de communication distincts deux à deux, on rajoute dans le signal
le numéro du processus dans le cycle. Formellement, on définit la fonction de sortie de Ap de
la façon suivante : pour tout s ∈ Qf , tout i ∈ ring−1 (p),
f p (s, Tokeni ) = f (s)
f p (s, Token′i ) = (s, i)
Lorsque le processus dans l’état Token a émis le signal de transmission du jeton, il réinitialise sa mémoire de son histoire locale, et repasse dans l’état NToken associé au numéro suivant
qu’il prendra dans le cycle. Le processus qui reçoit le signal passe lui en état Token et calcule
la nouvelle séquence d’événements sur le singleton en ajoutant l’histoire des événemets locaux
qu’il a mémorisée. Donc, pour tout p ∈ Proc, pour tout i ∈ ring−1 (p), pour tout s ∈ Qf , on
définit :
δp ((s, Token′i ), (s, i)) = (id, NTokensuccp (i) )
f
et pour tout δσ ∈ (Qf )Q , pour i ∈ {1, · · · , n} et p = ring((i mod n) + 1),
(
(δσ (s), Token(i mod n)+1 )
δp ((δσ , NToken(i mod n)+1 ), (s, i)) =
(δσ (s), Token′(i mod n)+1 )
si f (δσ (s)) ∈ Outp
sinon.
(4.4)
Enfin l’état initial de l’automate Ap est donné par :
 f

(s0 , Token1 )
p
s0 = (sf0 , Token′1 )


(id, NToken1 )
si ring(1) = p et f (sf0 ) ∈ Outp
si ring(1) = p et f (sf0 ) ∈
/ Outp
sinon
Remarque 4.42. On a l’invariant suivant : si Ap est dans un état (s, Tokeni ), avec i ∈ ring−1 (p),
alors f (s) est définie et f (s) ∈ Outp , et donc f p (s, Tokeni ) ∈ Outp .
134
Chapitre 4. Synthèse de systèmes asynchrones
On définit, pour tout i, j ∈ {1, . . . , n},
(
Qf × {i} si j = i + 1 ou i = n et j = 1
Σi,j =
∅
sinon.
Les alphabets de communication sont donc donnés par, pour tout (p, q) ∈ R,
]
Σp,q =
Σi,j .
i ∈ ring−1 (p)
j ∈ ring−1 (q)
Ainsi, on a bien, pour tout p ∈ Proc, δp : Qp × Σp → Qp .
Notation 4.43. On définit l’application s : M(Σ, D) → Πp∈Proc Qp , qui, à toute trace d’exécution finie α ∈ M(Σ, D), associe les états atteints par les différents automates (Ap )p∈Proc , s’ils
ont tous une exécution sur α : pour tout α ∈ M(Σ, D), pour tout p ∈ Proc,
(
δp (sp0 , πΣp (α)) si Ap a une exécution sur πΣp (α)
p
s (α) =
indéfini
sinon.
et, pour tout α ∈ M(Σ, D) tel que pour tout p ∈ Proc, sp (α) est défini, on pose
s(α) = (sp (α))p∈Proc .
On rappelle que comme πΣp (α) est un ordre total, πΣp (α) peut être vu comme un mot de Σ∗ .
On définit de même, pour tout α ∈ M(Γ, D), sf (α) = δf (sf0 , α).
On pose alors, pour tout α ∈ M(Σ, D), pour tout p ∈ Proc,
f p (α) = f p (sp (α))
et f p est bien à mémoire locale.
Avec ces notations, une exécution α = (X, ≤, λ) ∈ R(Σ, D) est F -compatible, si, pour
tout p ∈ Proc, tout x ∈ λ−1 (ΣpC ), λ(x) = f p (sp (α⇓α x )).
Pour tout p ∈ Proc, tout x ∈ λ−1 (Σp ), si sp (α↓α x ) ∈ Token, on pourra dire que « p a le
jeton en x ».
Comme on le souhaitait, les exécutions respectant la stratégie F présentent un certain
nombre de caractéristiques. On remarque en particulier :
Remarque 4.44. Soit α = (X, ≤, λ) ∈ R(Σ, D) une exécution F -compatible et F -équitable.
Alors elle a les caractéristiques suivantes :
1. Pour tout α1 préfixe de α, il existe un unique p ∈ Proc tel que sp (α1 ) ∈ Token. De plus,
pour tout x ∈ X tel que α1 · λ(x) est un préfixe de α,
– si λ(x) ∈
/ Σp , sp (α1 · λ(x)) = sp (α),
– si λ(x) ∈ Σp ∩ Γ, sp (α1 · λ(x)) ∈ Token,
/ Token et il existe un unique p′ ∈ Proc tel que
– si λ(x) ∈ Σp \ Γ, alors sp (α1 · λ(x)) ∈
′
′
−1
p,p
p
x ∈ λ (Σ ) et s (α1 · λ(x)) ∈ Token.
2. Les événements étiquetés par des actions contrôlables sont totalement ordonnés.
3. Pour toute trace α′ = (X ′ , ≤, λ) préfixe de α, pour tout p ∈ Proc, il existe un événement
z ∈ X \ X ′ tel qu’il existe q ∈ Proc, λ(z) ∈ Σq,p (et donc p a le jeton en z).
2. Résultats de décidabilité
135
4. Pour tous p, q ∈ Proc, tous x ∈ λ−1 (Σp ), y ∈ λ−1 (Σq ), si sp (α↓α x ) ∈ Token et sq (α↓α y ) ∈
Token, on a x ≤ y ou y ≤ x.
Démonstration.
1. On le démontre par récurrence sur les préfixes de α. Si α1 est
la trace vide, alors s(α1 ) = (sp0 )p∈Proc , et le processus ring(1) est le seul à vérifier
sring(1) (α1 ) ∈ Token. Soit α1 préfixe de α, p ∈ Proc tel que sp (α1 ) ∈ Token et soit x ∈ X
′′
tel que α1 ·λ(x) est un préfixe de α. Par définition de F , pour tout p′′ 6= p, F (α1 )∩ΣpC =
′
∅. Alors, si x ∈
/ λ−1 (Σp ), x ∈ λ−1 (In) et soit p′ ∈ Proc tel que x ∈ λ−1 (Σp ). Par
′
′
′′
′′
définition de δp , on a sp (α1 ·λ(x)) ∈
/ Token et pour tout p′′ 6= p′ , sp (α1 ·λ(x)) = sp (α1 ),
donc p est le seul processus à vérifier sp (α1 · λ(x)) ∈ Token. Si x ∈ λ−1 (Σp ∩ Γ), les
′
′
stratégies étant à mémoire locale, pour tout p′ 6= p, sp (α1 · λ(x)) = sp (α1 ) et par
définition de δp , on a sp (α1 · λ(x)) ∈ Token. Si x ∈ λ−1 (Σp \ Γ), alors il existe un unique
′
′
/ Token et sp (α1 · λ(x)) ∈ Token.
p′ ∈ Proc tel que x ∈ λ−1 (Σp,p ) et sp (α1 · λ(x)) ∈
′′
′′
Pour tout p′′ 6= p, p′ , on a sp (α1 · λ(x)) = sp (α1 ) ∈
/ Token. Donc il existe un unique
′
processus, maintenant p′ , vérifiant sp (α1 · λ(x)) ∈ Token.
2. Cette propriété découle immédiatement de 1. En effet, supposons qu’il existe deux événements z1 , z2 ∈ λ−1 (ΣC ) concurrents. Alors soient p1 ∈ Proc tel que z1 ∈ λ−1 (Σp1 )
et sp1 (α⇓α z1 ) ∈ Token et p2 ∈ Proc tel que z2 ∈ λ−1 (Σp2 ) et sp2 (α⇓α z2 ) ∈ Token. Soit
α′ = (X ′ , ≤′ , λ) trace préfixe de α telle que X ′ = ⇓α z1 ∪ ⇓α z2 . Comme z1 et z2 sont
concurrents, alors pour tout z ∈ X ′ ∩ λ−1 (Σp1 ), z < z1 et donc sp1 (α′ ) = sp1 (α⇓α z1 ).
De même, sp2 (α′ ) = sp2 (α⇓α z2 ). On obtient donc sp1 (α′ ) ∈ Token et sp2 (α′ ) ∈ Token, ce
qui est impossible.
3. Soit α′ = (X ′ , ≤, λ) une trace préfixe de α, et soit p ∈ Proc tel que sp (α′ ) ∈ Token.
Supposons que {x ∈ X \ X ′ | λ(x) ∈ ΣpC } est vide. Alors on peut montrer que pour
toute trace préfixe α′′ telle que α′ ≤ α′′ ≤ α, sp (α′′ ) ∈ Token, et donc f p (α′′ ) est
définie. On en déduit que α n’est pas F -équitable, ce qui est en contradiction avec
l’hypothèse. Soit donc x0 élément minimal de l’ensemble {x ∈ X \ X ′ | λ(x) ∈ ΣpC },
et on montre qu’alors il existe nécessairement une action de communication dans cet
ensemble, i.e., {x ∈ X \ X ′ | λ(x) ∈ ΣpC \ Γ} =
6 ∅. En effet, si λ(x0 ) ∈ ΣpC \ Γ, alors
l’ensemble est immédiatement non vide. Sinon, si λ(x0 ) ∈ Outp , alors par définition
de δp , sp (α⇓α x0 ) ∈ Qf × {Tokeni }, et sp (α↓α x0 ) ∈ Qf × {Token′i }, avec i ∈ ring−1 (p).
Comme α est équitable, on conclut qu’il existe nécessairement un élément x1 > x tel
que λ(x1 ) ∈ ΣpC \ Γ (sinon, pour tout α′′ trace préfixe vérifiant α↓α x0 ≤ α′′ ≤ α,
sp (α′′ ) ∈ Qf × {Token′i } et f p (α′′ ) ∈ ΣpC \ Γ). Soit x′ ∈ X le plus petit élément de
l’ensemble {x ∈ X \ X ′ | λ(x) ∈ ΣpC \ Γ}. Alors il existe un unique processus p′ ∈ Proc
′
tel que λ(x′ ) ∈ Σp,p : en fait, p′ = ring((i mod n) + 1).
On pose maintenant X ′′ = X ′ ∪ ↓α x′ , et α′′ = (X ′′ , ≤, λ) trace préfixe de α. On a
′
sp (α′′ ) ∈ Token, et on peut répéter le raisonnement ci-dessus sur le processus p′ . Comme
X ′ ⊆ X ′′ , et que l’application ring est surjective, en itérant le raisonnement, on obtient,
pour tout p ∈ Proc, l’existence d’un élément z ∈ X \ X ′ tel que λ(z) ∈ Σq,p , pour
q ∈ Proc.
4. Supposons x kα y. Alors p 6= q, et on considère la trace préfixe de α définie par α1 =
(↓α x ∪ ↓α y, ≤, λ). On remarque que ↓α x ∩ λ−1 (Σp ) = (↓α x ∪ ↓α y) ∩ λ−1 (Σp ). (sinon, il
existe z ∈ λ−1 (Σp ) tel que z ≤ y et x < z, ce qui implique x < y, en contradiction avec
l’hypothèse). De même, ↓α y ∩ λ−1 (Σq ) = (↓α x ∪ ↓α y) ∩ λ−1 (Σq ).
136
Chapitre 4. Synthèse de systèmes asynchrones
p
Donc sp (α1 ) = sp (πΣp (α1 )) = sp (πΣ
(α↓α x )) = sp (α↓α x ) ∈ Token, et, par le même
q
raisonnement, s (α1 ) ∈ Token, ce qui est impossible, d’après 1.
On montre à présent que la stratégie distribuée ainsi définie est gagnante.
Remarque 4.45. Il est important pour que la démonstration fonctionne, que l’on se réduise
au problème de SSD asynchrone équitable sur le singleton, avec équité par type d’actions. En
effet, une exécution équitable du singleton pour une stratégie f fixée dans le problème de SSD
asynchrone équitable classique est telle que, si le singleton désire continuellement effectuer une
action quelconque à partir d’un moment, alors le processus sera activé infiniment souvent. Ici
on s’est réduit au problème dans lequel une exécution équitable du singleton est telle que, si
le singleton désire continuellement effectuer une action au sein de la même partie des actions
(typiquement, les signaux de communication externe d’un processus donné), alors ce type
d’action sera joué infiniment souvent. Cela implique que dans une exécution équitable, si la
stratégie du singleton est continuellement définie, mais pas toujours dans la même partie des
actions, il n’est pas nécessaire que le singleton soit activé infiniment souvent. Ainsi, l’exécution
distribuée correspondante, dans laquelle le processus ayant le jeton n’est jamais celui devant
jouer selon la stratégie du singleton (lorsque le processus p a le jeton, le singleton veut jouer
dans la partie des actions Outq , etc.), et donc dans laquelle les processus ne désirent jamais
jouer d’action externe, correspond bien à une exécution équitable du singleton, ce qui n’aurait
pas été le cas avec la définition d’équité ne faisant pas de distinction entre les différentes actions
du singleton.
Par ailleurs, on remarque que si l’on aurait pu définir le problème pour des partitions plus
fines des actions des processus dans le cas distribué, on ne peut pas aller jusqu’à la partition
la plus fine P = {{a} | a ∈ Σ}. En effet, dans ce dernier cas, la notion d’équité ne permet
plus d’assurer que dans une exécution le jeton soit transmis infiniment entre les processus :
le processus ayant le jeton et désirant continuellement le transmettre ne veut pas envoyer le
même signal à chaque instant, mais bien la valeur courante de l’histoire sur le singleton qu’il
a reconstruite, qui peut changer à chaque nouveau signal reçu de l’environnement.
Soit α = (X, ≤, λ) ∈ R(Σ, D) une exécution F -compatible et F -équitable. On définit
une extension d’ordre α′ = (X, ≤′ , λ) de la façon suivante : deux événements x ∈ λ−1 (Σp )
et y ∈ λ−1 (Σq ) concurrents dans α sont ordonnés par x ≤′ y si la prochaine action de
communication après x précède la prochaine action de communication après y, ou bien si la
prochaine action de communication après x et y est la même et est un signal de p vers q.
L’ordre α′ représente la séquence d’actions du singleton que les processus vont simuler au
cours d’une exécution. En effet, si x ∈ λ−1 (Σp ) et y ∈ λ−1 (Σq ) sont concurrents dans α et
que la prochaine action de communication z après x est telle que z ∈ λ−1 (Σp,q ), alors cela
signifie que p a le jeton en x. Donc jusqu’à l’événement z c’est le processus p qui peut envoyer
des signaux externes. N’ayant pas connaissance de y, il ne peut simuler le singleton sur une
histoire contenant y, c’est pourquoi on veut que les événements vus par p soit placés avant
ceux vus par q. De façon générale, si le prochain événement de communication après x précède
le prochain événement de communication après y (on a vu dans la remarque 4.44 que de tels
événements de communication existent toujours, et de plus sont tous ordonnés), cela signifie
qu’un processus a eu le jeton en x avant qu’un processus ait le jeton en y.
Formellement, pour tout x ∈ X, soit x′ = min{y ≥ x | y ∈ λ−1 (Σ \ Γ)}. Un tel élément
existe toujours (par la remarque 4.44 (3)) et est unique (par la remarque 4.44 (2)).
137
2. Résultats de décidabilité
On définit alors


x ≤ y
′
x ≤ y si et seulement si x kα y


x kα y
1
α :2
a
a (qaa , 1) a
c (qaacc , 2)
c
req3
3
α′ :
ou
et x′ < y ′ , ou
et x′ = y ′ ∈ λ−1 (Σp,q ), et x ∈ λ−1 (Σp ), y ∈ λ−1 (Σq )
b
(qaaccreq3 b , 3)
a
a
c (qaa , 1) c
req3 (qaacc , 2) b
(qaaccreq3 b , 3)
a
Fig. 4.10 – Une exécution distribuée et sa linéarisation
Avant de montrer que la relation ainsi définie est bien une relation d’ordre totale, on
remarque les faits suivants :
Remarque 4.46.
1. Pour tout x ∈ X, on a soit x = x′ , soit x ∈ λ−1 (Γ) et il existe un
unique processus p ∈ Proc tel que λ(x) ∈ Σp ∩ Γ. De plus, l’ensemble {y ∈ X | x ≤ y ≤
x′ } ⊆ λ−1 (Σp ).
2. si x kα y et x′ = y ′ alors x, y ∈ λ−1 (Γ). En effet, si x ∈ λ−1 (Σ \ Γ), alors x = x′ = y ′ , et
y ≤ y ′ implique que y ≤ x, ce qui est en contradiction avec l’hypothèse.
3. Si x ≤′ y, alors x′ ≤ y ′ . En effet, si x kα y, alors on le déduit immédiatement de la
définition. Si x ≤ y et x = x′ , alors x′ ≤ y ≤ y ′ . Si x ≤ y et x < x′ , alors on pose
p ∈ Proc l’unique processus tel que x ∈ λ−1 (Σp ). On a {z ∈ X | z ≥ x} = {z ∈ X | x ≤
z ≤ x′ } ∪ {z ∈ X | z ≥ x′ } = {z ∈ λ−1 (Σp ) | z ≥ x} ∪ {z ∈ X | z ≥ x′ }. Alors, soit
x ≤ y < x′ et y ′ = x′ , soit x′ ≤ y ≤ y ′ .
4. Si x′ < y ′ alors x <′ y. En effet, si x ≤ y ou si x kα y, on le déduit de la définition.
Sinon, si y < x, alors y < x ≤ x′ < y ′ . Or y ′ est le plus petit élément vérifiant y ≤ y ′ et
y ′ ∈ λ−1 (Σ \ Γ). Comme x′ ∈ λ−1 (Σ \ Γ), on obtient une contradiction.
5. S’il existe x ∈ λ−1 (Γ ∩ Σring(1) ) tel que, pour tout y ∈ λ−1 (Σring(1) ), x ≤ y, alors pour
tout y ∈ X, x ≤′ y.
En effet, soit y ∈ X. Alors y 6< x (sinon il existe z ∈ λ−1 (Σring(1) ) tel que y ≤ z < x).
Deux cas sont donc possibles :
– Si x ≤ y, alors x ≤′ y.
– si x kα y, alors si x′ < y ′ , on a x <′ y. Si y ′ < x′ , alors nécessairement x kα y ′ (le cas
y ′ < x implique que y < x ce qui est impossible, et le cas x < y ′ < x′ est contradictoire
avec la définition de x′ ). Soit p ∈ Proc tel que y ′ ∈ λ−1 (Σp ) et sp (α↓α y′ ) ∈ Token (un
tel processus existe, par la remarque 4.44 (1), car y ′ correspond à un passage de jeton).
Puisque x kα y ′ , p 6= ring(1). Or, par définition de Aring(1) , sring(1) (α↓α x ) ∈ Token. Ceci
138
Chapitre 4. Synthèse de systèmes asynchrones
est impossible par la remarque 4.44 (4). Si enfin x′ = y ′ , alors il existe p ∈ Proc tel que
λ(x′ ) ∈ Σring(1),p et λ(y) ∈ Σp (si λ(x′ ) ∈ Σp,ring(1) , alors on aurait sq (α↓α y ) ∈ Token,
et ceci est en contradiction avec l’hypothèse x kα y, par la remarque 4.44 (4)). Donc
x ≤′ y.
Lemme 4.47. α′ est un ordre total.
Démonstration.
Montrons d’abord que ≤′ est une relation d’ordre.
– Il est clair que x ≤′ x par réflexivité de ≤.
– Soient x, y ∈ X tels que x ≤′ y et y ≤′ x. Si x ≤ y, alors y ≤′ x implique que y ≤ x. De
même, si y ≤ x alors x ≤′ y implique que x ≤ y. Donc si x ≤ y ou y ≤ x, nécessairement,
x ≤ y et y ≤ x, et par antisymétrie de ≤ on en déduit que x = y. Si x kα y, alors,
d’après la remarque 4.46, x′ ≤ y ′ . De la même façon on déduit du fait que y ≤′ x que
y ′ ≤ x′ . Donc, par antisymétrie de ≤, on obtient x′ = y ′ . Alors, par la remarque 4.46,
on sait que x, y ∈ λ−1 (Γ). Soient p, q ∈ Proc les uniques processus vérifiant x ∈ λ−1 (Σp )
et y ∈ λ−1 (Σq ). La définition de ≤′ implique que x′ , y ′ ∈ λ−1 (Σp,q ) ∩ λ−1 (Σq,p ). Les
alphabets de communication étant deux à deux disjoints, on obtient une contradiction.
Donc si x ≤′ y et y ≤′ x on a x = y.
– Soient x, y, z ∈ X tels que x ≤′ y et y ≤′ z. On cherche à montrer qu’alors x ≤′ z.
Par la remarque 4.46, et par transitivité de ≤, on a x′ ≤ y ′ ≤ z ′ . Si x′ < z ′ , alors par
définition de ≤′ , on a x ≤′ z. Sinon, x′ = y ′ = z ′ . On distingue deux cas
– si x kα y, alors la remarque 4.46 permet de déduire qu’il existe un unique p ∈ Proc
et un unique q ∈ Proc tels que respectivement, x ∈ λ−1 (Σp ) et y ∈ λ−1 (Σq ). Alors
x′ = y ′ = z ′ ∈ λ−1 (Σp,q ), et z ∈ λ−1 (Σp ) ∪ λ−1 (Σq ).
Si z ∈ λ−1 (Σp ), alors supposons que z ≤ x. Cela implique que z ≤′ x. Dans ce cas,
on en déduit que z kα y (sinon, soit y ≤ z ≤ x, ce qui est en contradiction avec
x kα y, soit, y étant un événement étiqueté par une action locale, et x′ étant la
prochaine action partagée après z, on aurait z ≤ x′ ≤ y. Or, y < y ′ = x′ , on aboutit
à une contradiction). Par définition de ≤′ , comme y ′ = z ′ ∈ λ−1 (Σp,q ), z ≤′ y. Par
antisymétrie de ≤′ , on obtient z = y, ce qui est impossible. Donc x ≤ z, et x ≤′ z.
Si z ∈ λ−1 (Σq \ Σp ), alors z ∈ λ−1 (Γ) et soit z < y, donc z <′ y ce qui est en
contradiction avec y ≤′ z, soit y ≤ z. Dans ce cas, comme z ∈ λ−1 (Γ), alors z < z ′ ,
et x kα z, avec x′ = z ′ ∈ λ−1 (Σp,q ) (une fois de plus, x et z étant des événements
correspondant à des actions locales sur deux processus distincts, la prochaine action
partagée après x et après z étant x′ , x ≤ z impliquerait x′ ≤ z et z ≤ x impliquerait
x′ ≤ x, ce qui est impossible). Donc, la définition de ≤′ permet de conclure que x ≤′ z.
– si x ≤ y, alors par la remarque 4.46, soit y = y ′ , soit y ∈ λ−1 (Γ). Si y = y ′ , alors la
relation z ≤ z ′ = y ′ implique que z ≤ y, et donc z ≤′ y. Par antisymétrie de ≤′ , on a
alors z = y et x ≤ z donc x ≤′ z. Sinon, on a x ≤ y < x′ = y ′ et il existe un unique
processus p ∈ Proc tel que x, y ∈ λ−1 (Σp ). Si y ≤ z, alors on obtient immédiatement
x ≤′ z. Si z < y, alors z <′ y, ce qui est impossible. Si enfin y kα z, comme y ′ = z ′
et y ≤′ z, alors il existe q ∈ Proc tel que y ′ , z ′ ∈ λ−1 (Σp,q ) avec z ∈ λ−1 (Σq ). Comme
x′ = y ′ = z ′ , x ≤′ z.
On montre ensuite que ≤′ est une relation totale. Soient p, q ∈ Proc et x ∈ λ−1 (Σp ) et
y ∈ λ−1 (Σq ) tels que x kα y. D’après la remarque 4.44 (2), x′ ≤ y ′ ou y ′ ≤ x′ . Si x′ = y ′ , alors
nécessairement λ(x′ ) ∈ Σp,q ⊎ Σq,p . Donc x ≤′ y ou y ≤′ x.
On supprime à présent de α′ les actions de communication internes. Soit αf = πΓ (α′ ), un
139
2. Résultats de décidabilité
ordre total dont on va montrer qu’il correspond à une exécution f -compatible et f -équitable :
Lemme 4.48. αf est une exécution f -compatible.
Pour cela on montre que, à chaque instant, le processus possédant le jeton, et donc à
même de produire une sortie, maintient une histoire consistante avec la linéarisation αf . On
commence par définir l’histoire du singleton simulée par les processus : soit p ∈ Proc et
x ∈ λ−1 (Σp ) tels que le processus p a le jeton en x. Alors à cet instant, l’état interne de Ap
est l’état dans lequel se trouverait l’automate Af après avoir vu les événements observables
dans le passé de x. Formellement on note
Notation 4.49. Pour tout α1 = (X1 , ≤, λ) ∈ M(Σ, D) trace préfixe de l’exécution α, soit
p ∈ Proc tel que sp (α1 ) ∈ Token. On note
(
max(X1 ∩ λ−1 (Σp )) si X1 ∩ λ−1 (Σp ) 6= ∅
ζ(α1 ) =
indéfini
sinon.
On définit alors l’ordre total
α1 = (X1 , ≤′ , λ)
avec X1 = ↓α ζ(α1 ) et la convention que ↓α ζ(α1 ) = ∅ si ζ(α1 ) n’est pas défini.
Remarque 4.50. si X1 ∩ λ−1 (Σp ) = ∅ et sp (α1 ) ∈ Token, nécessairement, p = ring(1), et
sp (α1 ) = {sf0 } × Tokenp .
On va utiliser les deux lemmes suivants : le premier établit le fait que lorsqu’un processus
a le jeton en x, l’ensemble des événements dans le passé causal de x dans α est exactement
l’ensemble des événements dans le passé causal de x dans α′ .
Lemme 4.51. Pour tout α1 = (X1 , ≤, λ) ∈ M(Σ, D) préfixe de α, soit p ∈ Proc tel que
sp (α1 ) ∈ Token. Alors, si X1 ∩ λ−1 (Σp ) 6= ∅, ↓α ζ(α1 ) = ↓α′ ζ(α1 ).
Démonstration du lemme 4.51.
Comme α′ est une extension linéaire de α, on a immédiatement ↓α ζ(α1 ) ⊆ ↓α′ ζ(α1 ). Soit donc y ∈ X tel que y ≤′ ζ(α1 ), et on va montrer
que y ≤ ζ(α1 ). Dans la suite de cette démonstration on pose z = ζ(α1 ). Soit α↓α y′ la trace
préfixe de α constituée des éléments dans le passé de y ′ = min{z ≥ y | z ∈ λ−1 (Σ \ Γ)},
et soit r ∈ Proc le processus tel que sr (α↓α y′ ) ∈ Token. Par la remarque 4.44 (1), un tel
processus existe toujours, et est unique. De plus, λ(y ′ ) ∈ Σr . Comme sp (α1 ) ∈ Token, et
que z est l’élément maximal de X1 ∩ λ−1 (Σp ), par la remarque 4.44 (4) on sait que y ′ ≤ z
ou z ≤ y ′ . Si y ′ ≤ z, alors immédiatement y ≤ z. Si z ≤ y ′ , alors soit y = y ′ , et alors
puisque y ≤′ z, nécessairement z = y, soit y < y ′ et supposons que y kα z. Alors on a
z ≤ z ′ ≤ y ′ et, par définition de ≤′ , y ′ ≤ z ′ , donc y ′ = z ′ . Par définition de ≤′ , cela imq
plique que z ′ ∈ λ−1 (Σq,p ) et y ∈ λ−1 (Σq ) et z ∈ λ−1 (Σp ). Par définition de f , et comme α
est F -compatible, sq (α⇓α y′ ) ∈ Token. Alors, puisque quel que soit y1 tel que y ≤ y1 < y ′ ,
λ(y1 ) ∈ Γ, on en déduit que sq (α↓α y ) ∈ Token, ce qui est en contradiction avec y kα z (par la
remarque 4.44 (4)). Donc y ≤ z, et ↓α ζ(α1 ) = ↓α′ ζ(α1 ).
Le second lemme affirme que l’état de Af simulé par un processus ayant le jeton correspond
à l’état que Af aurait atteint après avoir exécuté les actions dans le passé causal de l’événement
courant de α, mais ordonnées par ≤′ .
140
Chapitre 4. Synthèse de systèmes asynchrones
Lemme 4.52. Pour tout α1 = (X1 , ≤, λ) ∈ M(Σ, D) préfixe de α, pour tout p ∈ Proc tel que
sp (α1 ) ∈ Token, sp (α1 ) ∈ {sf (πΓ (α1 ))} × Tokenp .
Ainsi, αf étant la projection de α′ sur les actions de Γ, on en déduit que le processus ayant
le jeton simule correctement l’exécution αf .
Avant de prouver cette affirmation, on montre comment les deux lemmes précédents permettent de démontrer le résultat :
Soit p ∈ Proc et x ∈ λ−1 (Outp ). Comme α est une
Démonstration du lemme 4.48.
exécution F -compatible, λ(x) = f p (sp (α⇓α x )). Ceci implique qu’il existe i ∈ ring−1 (p), et
s ∈ Qf tels que sp (α⇓α x ) = (s, Tokeni ), et f (s) = λ(x). Comme α⇓α x est un préfixe de α, le
lemme 4.52 nous dit que sf (πΓ (α⇓α x)) = s, avec α⇓α x = (⇓α x, ≤′ , λ). Soit αf1 = (⇓αf x, ≤′ , λ).
On veut alors montrer que πΓ (α⇓α x ) = αf1 . Ainsi, sf (πΓ (α⇓α x )) = sf (αf1 ) = s et λ(x) =
f (sf (αf1 )).
Si x n’a pas de prédécesseur sur λ−1 (Σp ), alors ⇓α x = ∅, et p = ring(1). Par la remarque 4.46 (5), on sait que x est l’élément minimal de α′ , donc de αf . Donc ⇓αf x = ∅, et
πΓ (α⇓α x ) = αf1 .
Sinon, ⇓α x = ↓α ζ(α1 ). Dans ce cas, le lemme 4.51 implique que ↓α ζ(α1 ) = ↓′α ζ(α1 ) =
{y ∈ X | y ≤′ ζ(α1 )} = {y ∈ X | y <′ x} (x étant un événement local, l’ensemble de
ses prédécesseurs stricts est égal à l’ensemble des événements dans le passé de son unique
prédécesseur. Or, il est clair que ζ(α1 ) est le prédécesseur de x dans α). Donc πΓ (α⇓α x ) = αf1 .
On en déduit que αf ∈ Γ∞ est bien une exécution f -compatible.
Démonstration du lemme 4.52.
On procède par récurrence sur les préfixes de α.
Si α1 est la trace vide, alors sring(1) (α1 ) ∈ {sf0 } × Tokenring(1) . De plus, α1 est également
vide, donc on a bien sring(1) (α1 ) ∈ {sf (πΓ (α1 ))} × Tokenring(1) .
Soit α1 = (X1 , ≤, λ) une trace préfixe de α et p ∈ Proc tel que sp (α) ∈ Token. Soit
x ∈ X \ X1 tel que ⇓x ⊆ X1 . Soit a = λ(x). On a α1 · a = (X1 ∪ {x}, ≤, λ) est un préfixe
de α. Si a ∈
/ Σp , par la remarque 4.44 (1), sp (α1 · a) = sp (α1 ). Par hypothèse de récurrence,
sp (α1 · a) ∈ {sf (πΓ (α1 ))} × Tokenp . De plus, les éléments de (α1 · a) sont exactement X1 ,
puisque max(X1 ∩ λ−1 (Σp )) = max(X1 ∪ {x} ∩ λ−1 (Σp )). Donc α1 · a = α1 et sp (α1 · a) ∈
{sf (πΓ (α1 · a))} × Tokenp .
Si a ∈ Σp ∩Γ, alors sp (α1 ·a) ∈ Token, et, en utilisant l’hypothèse de récurrence, sp (α1 ·a) ∈
f
{δ (sf (πΓ (α1 )), a)}×Token p . Par ailleurs, x = max(X1 ∪{x}∩λ−1 (Σp )) et ⇓α x = ↓α max(X1 ∩
λ−1 (Σp )) (car x est un événement local), donc α1 · a = α1 · a. Donc δf (sf (πΓ (α1 )), a) =
sf (πΓ (α1 · a)). On obtient donc sp (α1 · a) ∈ {sf (πΓ (α1 · a))} × Tokenp .
Le cas le plus délicat est si a ∈ Σp \Γ. Il s’agit du moment où les processus se transmettent
le jeton, et où ils réordonnent les événements concurrents qui ont eu lieu : ceux transmis par
le processus émetteur du signal, et ceux reçus par le processus récepteur tant qu’il n’avait
pas le jeton. Il s’agit de montrer formellement que l’état calculé par le processus récepteur
correspond bien à l’état atteint par Af après avoir vu les événements dans le passé de ce signal
de communication, ordonnés par ≤′ . Soit donc q ∈ Proc tel que sq (α1 · a) ∈ Token. On définit
last-token(x) le dernier événement de Σq correspondant à un envoi de jeton. Formellement,
on pose
last-token(x) = max(λ−1 (Σq ) ∩ ↓α ζ(α1 ))
avec la convention que ↓α ζ(α1 ) = ∅ si ζ(α1 ) n’est pas défini. Il est clair que last-token(x)
correspond bien au dernier événement de communication sur q avant x : comme ζ(α1 ) ∈ Σp ,
141
2. Résultats de décidabilité
et p 6= q, le plus grand événement dans λ−1 (Σq ∩↓α ζ(α1 )) est nécessairement dans λ−1 (Σq \Γ).
De plus, il n’existe aucun événement z ∈ λ−1 (Σq \ Γ) tel que last-token(x) < z < x. Si un
tel z existe, alors soit z kα ζ(α1 ), et alors il existe un processus p′ 6= p tel que p′ a le jeton
en z. Comme, par ailleurs, p a le jeton en ζ(α1 ), la remarque 4.44 (4) nous dit que c’est
impossible. Sinon ζ(α1 ) < z, et on obtient une contradiction avec la définition de ζ(α1 ) (si
z ∈ λ−1 (Σp , alors ζ(α1 ) 6= max(X1 ∩ λ−1 (Σp )), si z ∈
/ λ−1 (Σp ), alors il existe z ′ ∈ λ−1 (Σp ) tel
′
que ζ(α1 ) < z < z). On définit alors l’ordre total formé des actions locales observées par q
entre last-token(x) et x :
α(last-token(x)) = (Xα(last-token(x)) , ≤, λ)
où Xα(last-token(x)) = λ−1 (Σq ) ∩ (⇓α x \ ↓α ζ(α1 )).
↓α ζ(α1 )
p
q
ζ(α1 ) x
last-token(x)
Xα(last-token(x))
Fig. 4.11 – Les éléments de Xα(last-token(x))
Si last-token(x) existe, nécessairement, c’est une émission du jeton par q, donc par définition de Aq , sq (α⇓α last-token(x) ) ∈ Token, et on en déduit que sq (α1 ) = (δα(last-token(x)) , NTokeni ),
pour i ∈ ring−1 (q). La définition de δq et l’hypothèse de récurrence permettent de conclure
que
sq (α1 · a) ∈ {δf (s, α(last-token(x)))} × Tokenq .
où s = sf (πΓ (α1 )).
Soit α1 · a = (Xα1 ·a , ≤, λ). Par définition, Xα1 ·a = ↓α ζ(α1 · a) = ↓α x, X1 = ↓α ζ(α1 ) et
Xα(last-token(x)) = λ−1 (Σq ) ∩ (⇓α x \ ↓α ζ(α1 )). En fait, ⇓α x \ ↓α ζ(α1 ) ⊆ λ−1 (Σq ). En effet,
puisque x ∈ λ−1 (Σp,q ), si on note xq = max(λ−1 (Σq ) ∩ ⇓α x), on a ⇓α x = (↓α ζ(α1 )) ∪ (↓α xq ).
Or, tout z ∈ λ−1 (Σq ) tel que last-token(x) < z < x est tel que z ∈ λ−1 (Γ), donc tout élément
de ⇓α x \ ↓α ζ(α1 ) ∈ λ−1 (Σq ). Si ↓α ζ(α1 ) = ∅, alors nécessairement p = ring(1), et x est la
première communication de l’exécution. Donc ⇓α x ⊆ λ−1 (Σq ). Il est donc évident à partir de
ces définitions que X1 ∪ Xα(last-token(x)) ∪ {x} = ↓α ζ(α1 ) ∪ (⇓α x \ ↓α ζ(α1 )) ∪ {x} = Xα1 ·a .
Pour tout y ∈ Xα(last-token(x)) , on a ζ(α1 ) ≤′ y. En effet, ou bien ζ(α1 ) < y, ou bien
ζ(α1 ) kα y et alors ζ(α1 )′ ≤ x = y ′ . Alors, deux cas sont possibles : soit ζ(α1 )′ = ζ(α1 ) <
x = y ′ et donc ζ(α1 ) ≤′ y. Soit ζ(α1 )′ = x = y ′ ∈ λ−1 (Σp,q ) donc ζ(α1 ) ≤′ y. Donc
α1 · a = α1 · α(last-token(x)) · a et πΓ (α1 · a) = πΓ (α1 ) · α(last-token(x)).
On a donc bien sf (πΓ (α1 · a)) = δf (s, α(last-token(x))) avec s = sf (πΓ (α1 )), ce qui conclut
la démonstration.
Lemme 4.53. αf est une exécution f -équitable, pour la partition P = {Outp | p ∈ Proc}.
Démonstration.
Soit un processus p ∈ Proc et α′f = (Xf′ , ≤′ , λ) une trace préfixe de αf
telle que pour toute trace α′′f vérifiant α′f ≤ α′′f ≤ αf , on a f (sf (α′′f )) ∈ Outp . On considère
142
Chapitre 4. Synthèse de systèmes asynchrones
alors une telle trace préfixe α′′f = (Xf′′ , ≤′ , λ). Soit q ∈ Proc et x ∈ λ−1 (Σq,p ) \ Xf′′ (un tel
événement existe d’après la remarque 4.44 (3)). Supposons que, pour tout y ≥ x, λ(y) ∈
/ Outp .
Alors on montre que
∀y ≥ x tel que λ(y) ∈ Σp , sp (α↓α y ) = (sf (α↓α y f ), Tokeni )
P (y)
avec i ∈ ring−1 (p), et α↓α y f = πΓ (α↓α y ).
On démontre la propriété P (y) par récurrence. On sait que sp (α↓α x ) ∈ Token, donc x =
ζ(α↓α x ). Alors, par le lemme 4.51, ↓α x = ↓α′ x. Par le lemme 4.52, on obtient sp (α↓α x ) ∈
{sf (α↓α x f )} × Token. Par ailleurs, ≤′ étant un ordre total, on sait que Xf′′ ⊆ ↓α′ x (puisque
x∈
/ Xf′′ ). Donc α′f ≤ α′′f ≤ α↓α x f , et f (sf (α↓α x f )) ∈ Outp . Donc par l’équation (4.4) de la
définition de δp , on en déduit que sp (α↓α x ) = (sf (α↓α x f ), Tokeni ), pour i ∈ ring−1 (p). Ceci
constitue le cas de base de la récurrence.
Soit à présent y ≥ x, tel que λ(y) ∈ Σp , et supposons P (y) vérifiée. Alors par l’invariant de
Ap relevé dans la remarque 4.42, puisque sp (α↓α y ) = (sf (α↓α y f ), Tokeni ), pour i ∈ ring−1 (p),
on a f p (sp (α↓α y )) ∈ Outp .
Soit z le successeur de y sur Σp , et soit a ∈ Σp tel que λ(z) = a. Si λ(z) = f p (sp (α↓α y )) ∈
Outp , alors il existe y ≥ x tel que λ(y) ∈ Outp , ce qui est en contradiction avec l’hypothèse.
Donc, par définition des stratégies, λ(z) ∈ Inp , et sp (α↓α z ) ∈ Token. On sait que α↓α z = α↓α y ·a.
Comme α′′f ≤ α↓α y f ≤ α↓α z f , on a donc par hypothèse f (sf (α↓α z f )) ∈ Outp , avec sf (α↓α z f ) =
δf (sf (α↓α y f ), a). Donc, en appliquant la fonction de transition δp de l’équation (4.3), on
obtient sp (α↓α z ) = δp (sp (α↓α y ), a) = (δf (sf (α↓α y f ), a), Token i ) = (sf (α↓α z f ), Tokeni ), et P (z)
est vérifiée.
L’invariant de Ap permet de conclure que pour tout y ≥ x tel que λ(y) ∈ Σp , f p (α↓α y ) ∈
Outp , donc pour toute trace α′′ telle que α↓α x ≤ α′′ ≤ α, F (α′′ ) ∩ ΣpC 6= ∅. Comme α est
F -équitable, ceci est en contradiction avec l’hypothèse que pour tout x′ ≥ x, λ(x′ ) ∈
/ Outp .
′
′′
′
′
′′
Donc il existe x ≥ x, λ(x ) ∈ Outp , et pour tout αf = (Xf , ≤ , λ) trace préfixe de αf telle
que α′f ≤ α′′f ≤ αf , il existe x ∈ Xf \ Xf′′ tel que λ(x) ∈ Outp , donc αf est f -équitable pour
la partition {Outp | p ∈ Proc}.
Il nous reste à montrer que l’exécution observable πΓ (α) est un affaiblissement de αf . On
rappelle (voir la définition donnée par l’équation (4.1) page 111) que pour un ordre partiel
t = (X, ≤, λ), on définit l’ensemble
Wt = {(x, x′ ) ∈ X 2 | ∃p ∈ Proc, λ(x) ∈
/ Σp ∧ λ(x′ ) ∈ Inp ∧ z < z ′
∧ (¬∃y, λ(y) ∈ Outp ∧ x < y < x′ )}
comme étant l’ensemble maximal de paires d’éléments pour lesquels la relation d’ordre peut
être supprimée lors d’un affaiblissement.
On va pour cela utiliser le lemme suivant :
Lemme 4.54. Pour tous x, y ∈ λ−1 (Γ) tels que x kα y, si x ≤′ y alors λ(y) ∈ In.
Démonstration.
Soient x, y ∈ λ−1 (Γ) concurrents dans α et tels que x ≤′ y. Supposons
qu’il existe q ∈ Proc tel que λ(y) ∈ Outq . Alors il existe p 6= q ∈ Proc tel que λ(x) ∈ Inp (on
rappelle que d’après la remarque 4.44 (2), les signaux contrôlables par le système, donc en
particulier les sorties, sont tous ordonnés dans α). Considérons les deux événements étiquetés
par des signaux de communication interne x′ et y ′ vérifiant x′ = min{z ≥ x | z ∈ λ−1 (Σ \ Γ)}
3. Bilan
143
et y ′ = min{z ≥ y | z ∈ λ−1 (Σ \ Γ)}. Par définition de ≤′ , on a x′ ≤ y ′ . Comme λ(y) ∈ Outq ,
nécessairement, sq (↓α y) ∈ Token, et le prochain signal de communication impliquant q est un
signal émis par q. Donc, si x′ = y ′ , y ′ ∈
/ λ−1 (Σp,q ) et on n’a pas x ≤′ y. Donc x′ < y ′ , et même
′
′
′
′
−1
q
x ≤ z < y où z ∈ λ (Σ \ Γ) est le signal de communication précédant y ′ , i.e., tel que pour
tout z ′ < z < y ′ , si λ(z) ∈ Σq , alors λ(z) ∈ Γ. Par définition de y ′ , z ′ < y. On obtient donc
x < x′ ≤ z ′ < y, ce qui est en contradiction avec l’hypothèse que x kα y.
Donc λ(y) ∈ In.
On peut à présent conclure la démonstration. Soient z1 et z2 ∈ λ−1 (Γ) tels que z1 <αf z2 ,
i.e., z1 <′ z2 et z1 kα z2 . On va montrer que (z1 , z2 ) ∈ Wαf . D’après le lemme 4.54, on sait
que λ(z2 ) ∈ In. Soit p ∈ Proc le processus tel que λ(z2 ) ∈ Inp . Alors λ(z1 ) ∈
/ Σp . Supposons
maintenant qu’il existe y tel que λ(y) ∈ Outp et z1 <′ y <′ z2 . Alors z1 kα y (sinon on aurait
z1 ≤ z2 ). Or, le lemme 4.54 implique que λ(y) ∈ In, ce qui contredit λ(y) ∈ Outp . Donc
(z1 , z2 ) ∈ Wαf . On en déduit que πΓ (α) est une extension de l’affaiblissement de αf .
On a montré que αf est une exécution f -compatible et f -équitable pour la partition des
actions P = {Outp | p ∈ Proc}. Alors, f étant une stratégie gagnante pour (S, ϕ), on a
αf |= ϕ. Donc, par les propriétés de clôture d’AlocTL, πΓ (α) |= ϕ. On en conclut que F est
une stratégie distribuée gagnante pour (A, ϕ), où A est l’architecture induite par l’alphabet
de communication (Σp,q )(p,q)∈R .
Les propositions 4.35 et 4.41 permettent donc de démontrer le résultat annoncé par le
théorème 4.34. En effet, pour résoudre le problème de SSD asynchrone équitable sur (S, ϕ)
avec S une structure fortement connexe, et ϕ ∈ AlocTL, il suffit de trouver une stratégie
gagnante pour le problème de SSD asynchrone équitable, vis-à-vis d’une partition particulière
des actions, sur (S, ϕ), avec S et ϕ une structure singleton et une spécification LTL tels que
définis page 126. Par le théorème 4.22, ce dernier problème est décidable, et de plus s’il existe
une stratégie gagnante, il en existe une à mémoire finie. Donc, d’après la proposition 4.41,
on en conclut que s’il existe une stratégie distribuée gagnante pour (S, ϕ), il en existe une à
mémoire finie.
3
Bilan
On a défini un nouveau modèle pour le problème de synthèse de systèmes distribués
asynchrones, dans lequel on a considéré des notions d’équité, pour lequel la sous-classe des
structures fortement connexes est décidable. Ceci constitue une augmentation du nombre
d’architectures décidables par rapport au cas synchrone : en effet, on a vu qu’en général le
problème de synthèse de systèmes distribués synchrones n’est pas décidable pour les architectures fortement connexes. On montrera également dans un travail à soumettre prochainement
que le problème de SSD asynchrone équitable est décidable pour les structures totalement
déconnectées telles que celles correspondant au graphe de communication représenté sur la
figure 2.4 page 32, ainsi que celles correspondant à la figure 4.1 page 104.
144
Chapitre 4. Synthèse de systèmes asynchrones
Chapitre 5
Conclusion
1
Bilan
Ce travail avait pour but d’étudier les différentes causes d’indécidabilité du problème de
synthèse des systèmes distribués ouverts, afin de proposer des restrictions raisonnables sur les
hypothèses permettant de dégager des cas particuliers – naturels d’un point de vue applicatif
– qui soient décidables.
Systèmes synchrones Historiquement, la synthèse des systèmes distribués a été abordée
en supposant des exécutions synchrones des processus. Sous ces hypothèses, le nombre de cas
décidables est très restreint. On a montré qu’autoriser les spécifications à contraindre toutes
les variables du système était une hypothèse trop forte pour l’établissement d’un critère de décidabilité basé sur la structure des architectures. En effet, les seules architectures décidables
sous ces hypothèses sont celles dans lesquelles l’information provenant de l’environnement
est transmise linéairement (sans branchement) parmi les processus. Au contraire, on a mis
en évidence que restreindre les spécifications aux formules ne décrivant que les comportements acceptables externes permet d’agrandir substantiellement la classe des architectures
décidables, tout en restant une restriction naturelle d’un point de vue pratique. Par ailleurs,
si le problème de synthèse est décidable pour les architectures UWC si et seulement si elles
sont à information linéairement préordonnée, on peut obtenir la décidabilité du problème
pour toute cette sous-classe en se restreignant aux spécifications robustes : contrairement aux
spécifications externes générales, les spécifications robustes tiennent compte de la structure
de l’architecture en ne mettant en relation que les valeurs de variables connectées dans l’architecture. Enfin, on a mis en lumière le fait intéressant que, bien qu’il importe peu pour
la décidabilité que les processus en sortie reçoivent l’information de l’environnement avec un
retard (dû aux délais de transmission dans l’architecture), il est par contre crucial qu’ils reçoivent toute l’information possible. En effet, la preuve d’indécidabilité de [PR90] reposait
fortement sur le fait que la spécification faisait dépendre les valeurs en sortie d’un processus
de valeurs en entrée auxquelles il n’avait pas accès. On a montré que, si ce processus peut
connaı̂tre ces valeurs, non seulement la preuve d’indécidabilité ne fonctionne plus, mais l’architecture devient décidable pour le problème de SSD synchrone (car elle devient UWC à
information linéairement préordonnée). Mais on a également montré qu’il suffit que le processus manque un bit sur toute la séquence des valeurs de cette variable en entrée pour que
l’architecture redevienne indécidable.
145
146
Chapitre 5. Conclusion
Systèmes asynchrones Pour les systèmes asynchrones, la situation semble moins critique.
On a défini un nouveau cadre pour le problème de synthèse de systèmes asynchrones, qui correspond à une restriction d’une part des communications à des communications par signaux,
et d’autre part des spécifications à des spécifications externes et acceptables. Par ailleurs, on a
considéré le problème de synthèse sous des conditions d’équité pour les processus. On a montré que dans ce cas, on obtient la décidabilité du problème pour une sous-classe intéressante
d’architectures, les architectures fortement connexes, qui ne sont en général pas décidables,
en particulier dans le cas synchrone. La démonstration fonctionne par une réduction au cas
particulier du singleton, ce qui nous donne en plus l’assurance de l’existence d’une stratégie
à mémoire finie, dans le cas où une stratégie distribuée est possible.
Le modèle choisi autorise une mémoire uniquement locale aux contrôleurs, qui est plus
concrète que la mémoire causale considérée dans [GLZ04, MTY05]. Il est envisageable que
l’on obtienne la décidabilité du problème pour l’ensemble des architectures dans notre cadre,
le résultat présenté dans ce document ne constituant qu’une première étape de résolution.
2
Perspectives
Dans les deux cas, les solutions apportées dans ce document ouvrent un certain nombre
de pistes de recherche future. Dans le cas de systèmes synchrones, on a démontré que le problème de synthèse est décidable pour toutes les architectures UWC lorsqu’on se restreint aux
spécifications robustes. Il serait intéressant de voir si cela est toujours vrai pour les architectures bien connectées. On peut également chercher à étendre encore la classe des architectures
décidables lorsqu’elles sont à information linéairement préordonnée. La technique de preuve
pour les architectures UWC consiste à découper le « travail » des processus en deux étapes :
une partie routage de l’information, et une partie calcul proprement dit par les processus
en sortie. Un candidat potentiel pour une classe décidable serait les architectures dans lesquelles il n’est pas possible de router toute l’information jusqu’aux processus en sortie, mais
dans lesquelles on peut effectuer le calcul demandé par la spécification plus tôt, puis router
le résultat jusqu’à la sortie. Par ailleurs, on a établi la complexité du problème consistant à
vérifier si une architecture est UWC. Pour les architectures bien connectées, dans le cas où
il n’y a pas de délai, le problème se ramène à un problème de flot et peut donc être résolu
en temps polynomial. Cependant, si on considère des processus ayant des délais non nuls, le
problème devient plus compliqué, et il pourrait être intéressant d’établir sa complexité dans
le cas général.
Pour les systèmes asynchrones, le modèle que l’on a mis en place semble assez prometteur.
Tout d’abord, on n’a pour le moment mis en lumière aucun résultat d’indécidabilité avec ces
hypothèses. Une prolongation naturelle et importante de ce travail serait de voir si l’on peut
obtenir la décidabilité pour toutes les architectures. Avec cet objectif, les résultats exposés
dans ce document constituent une première étape pour une résolution modulaire du problème,
et il semble possible d’adapter la technique de démonstration consistant à se réduire au singleton à d’autres cas (comme les architectures totalement déconnectées, ou les architectures
de type pipeline comme celle représentée sur la figure 4.1 page 104). Dans le cas contraire, i.e.,
s’il se trouve que l’on ne peut pas obtenir la décidabilité du problème dans tous les cas, une
démonstration d’indécidabilité dans ce modèle apporterait des éléments de compréhension
supplémentaires sur le problème de SSD asynchrone.
Par ailleurs, on s’est ici contenté de définir la logique AlocTL comme candidate à nos
2. Perspectives
147
spécifications acceptables. Ce n’est probablement pas le formalisme de spécification le plus
puissant permettant d’obtenir le résultat. On pourrait donc étudier l’expressivité de cette
logique d’une part, et d’autre part définir éventuellement d’autres logiques pour les spécifications acceptables.
De façon plus générale, ce travail peut également être prolongé par l’étude de la synthèse
de systèmes distribués tolérants aux fautes. Jusqu’à présent, les processus considérés étaient
supposés « infaillibles ». Dans les applications réelles, les processus peuvent disfonctionner. On
s’intéresse donc à savoir si une certaine propriété est réalisable par un système distribué dans
lequel les processus peuvent faillir à un moment donné. Ce travail pourrait utiliser comme
point de départ les travaux sur le Model-checking de systèmes tolérants aux fautes.
148
Chapitre 5. Conclusion
Bibliographie
[ACLY00] Rudolf Ahlswede, Ning Cai, Shuo-Yen Robert Li, and Raymond W. Yeung. Network information flow. IEEE Transactions on Information Theory, 46(4) :1204–
1216, 2000.
[ALW89] Martı́n Abadi, Leslie Lamport, and Pierre Wolper. Realizable and unrealizable specifications of reactive systems. In Giorgio Ausiello, Mariangiola DezaniCiancaglini, and Simona Ronchi Della Rocca, editors, Proceedings of the 16th International Colloquium on Automata, Languages and Programming (ICALP’89),
volume 372 of Lecture Notes in Computer Science, pages 1–17. Springer, 1989.
[AM94]
Anuchit Anuchitankul and Zohar Manna. Realizability and synthesis of reactive
modules. In David L. Dill, editor, Proceedings of the 6th International Conference on Computer Aided Verification (CAV’94), volume 818 of Lecture Notes in
Computer Science, pages 156–168, Stanford, California, USA, 1994. Springer.
[AVW03] André Arnold, Aymeric Vincent, and Igor Walukiewicz. Games for synthesis of
controllers with partial observation. Theoretical Computer Science, 1(303) :7–34,
2003.
[BJ05]
Julien Bernet and David Janin. Tree automata and discrete distributed games. In
Maciej Liskiewicz and Rüdiger Reischuk, editors, Proceedings of the 15th International Symposium on Fundamentals of Computation Theory (FCT’05), volume
3623 of Lecture Notes in Computer Science, pages 540–551. Springer, 2005.
[BJ06]
Julien Bernet and David Janin. On distributed program specification and synthesis in architectures with cycles. In Elie Najm, Jean-François Pradat-Peyre, and
Véronique Donzeau-Gouge, editors, Proceedings of the 26th IFIP WG6.1 International Conference on Formal Techniques for Networked and Distributed Systems
(FORTE’06), volume 4229 of Lecture Notes in Computer Science, pages 175–190.
Springer, 2006.
[BL69]
J. Richard Büchi and Lawrence H. Landweber. Solving sequential conditions
by finite-state strategies. Transactions of the American Mathematical Society,
138 :295–311, 1969.
[CE81]
Edmund M. Clarke and E. Allen Emerson. Design and synthesis of synchronization skeletons using branching time temporal logic. In Proceedings of the IBM
Workshop on Logics of Programs, 1981.
[CGS09]
Thomas Chatain, Paul Gastin, and Nathalie Sznajder. Natural specifications yield
decidability for distributed synthesis of asynchronous systems. In Proceedings of
the 35th International Conference on Current Trends in Theory and Practice of
Computer Science (SOFSEM’09), Lecture Notes in Computer Science. Springer,
2009.
149
150
[Chu63]
[DG01]
[EC82]
[EH83]
[EJ99]
[FS05]
[FS06]
[Gab87]
[Gas90]
[GK07]
[GLZ04]
[GP95]
[GPSS80]
BIBLIOGRAPHIE
Alonzo Church. Logic, arithmetics, and automata. In Proceedings of the International Congress of Mathematicians, pages 23–35, 1963.
Volker Diekert and Paul Gastin. Local temporal logic is expressively complete
for cograph dependence alphabets. In Robert Nieuwenhuis and Andrei Voronkov,
editors, Proceedings of the 8th International Conference on Logic for Programming, Artificial Intelligence, and Reasoning (LPAR’01), volume 2250 of Lecture
Notes in Computer Science, pages 55–69. Springer, 2001.
E. Allen Emerson and Edmund. M. Clarke. Using branching time temporal logic to synthesize synchronization skeletons. Science of Computer Programming,
2(3) :241–266, 1982.
E. Allen Emerson and Joseph Y. Halpern. “Sometimes” and “Not Never” revisited : On branching versus linear time. In Proceedings of the 10th Annual ACM
Symposium on Principles of Programming Languages (POPL’83), pages 127–140.
ACM Press, 1983.
E. Allen Emerson and Charanjit S. Jutla. The complexity of tree automata and
logics of programs. SIAM Journal on Computing, 29(1) :132–158, 1999.
Bernd Finkbeiner and Sven Schewe. Uniform distributed synthesis. In Proceedings of the 20th IEEE Annual Symposium on Logic in Computer Science
(LICS’05), pages 321–330. IEEE Computer Society Press, 2005.
Bernd Finkbeiner and Sven Schewe. Synthesis of asynchronous systems. In
Germán Puebla, editor, Proceedings of the International Symposium on Logicbased Program Synthesis and Transformation (LOPSTR’06), volume 4407 of Lecture Notes in Computer Science, pages 127–142. Springer, 2006.
Dov M. Gabbay. The declarative past and imperative future : Executable temporal logic for interactive systems. In Behnam Banieqbal, Howard Barringer, and
Amir Pnueli, editors, Temporal Logic in Specification, Proceedings, volume 398 of
Lecture Notes in Computer Science, pages 409–448. Springer, 1987.
Paul Gastin. Infinite traces. In Irène Guessarian, editor, Semantics of Systems of
Concurrent Processes, Proceedings of LITP Spring School on Theoretical Computer Science, volume 469 of Lecture Notes in Computer Science, pages 277–308.
Springer, 1990.
Paul Gastin and Dietrich Kuske. Uniform satisfiability in PSPACE for local temporal logics over Mazurkiewicz traces. Fundamenta Informaticae, 80(1-3) :169–
197, 2007.
Paul Gastin, Benjamin Lerman, and Marc Zeitoun. Distributed games with causal
memory are decidable for series-parallel systems. In Kamal Lodaya and Meena
Mahajan, editors, Proceedings of the 24th Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS’04), volume 3328
of Lecture Notes in Computer Science, pages 275–286. Springer, 2004.
Paul Gastin and Antoine Petit. The book of traces, chapter 11 : Infinite Traces.
World Scientific, 1995.
Dov M. Gabbay, Amir Pnueli, Saharon Shelah, and Jonathan Stavi. On the
temporal basis of fairness. In Proceedings of the 7th Annual ACM Symposium on
Principles of Programming Languages (POPL’80), pages 163–173. ACM Press,
1980.
BIBLIOGRAPHIE
151
[GSZ06]
Paul Gastin, Nathalie Sznajder, and Marc Zeitoun. Distributed synthesis for wellconnected architectures. In Naveen Garg and S. Arun-Kumar, editors, Proceedings of the 26th Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS’06), volume 4337 of Lecture Notes in Computer
Science, pages 321–332. Springer, 2006.
[GSZ09]
Paul Gastin, Nathalie Sznajder, and Marc Zeitoun. Distributed synthesis for
well-connected architectures. Formal Methods in System Design, 34(3) :215–237,
2009.
[Kam68]
H. W. Kamp. Tense Logic and the Theory of Linear Order. Ph.d. thesis, University
of California, Los Angeles, 1968.
[KMTV00] Orna Kupferman, P. Madhusudan, P. S. Thiagarajan, and Moshe Y. Vardi. Open
systems in reactive environments : Control and synthesis. In Catuscia Palamidessi,
editor, Proceedings of the 11th International Conference on Concurrency Theory
(CONCUR’00), volume 1877 of Lecture Notes in Computer Science, pages 92–107.
Springer, 2000.
[Koz83]
Dexter Kozen. Results on the propositional mu-calculus. Theoretical Computer
Science, 27 :333–354, 1983.
[KV97]
Orna Kupferman and Moshe Y. Vardi. Synthesis with incomplete information. In
Proceedings of the 2nd International Conference on Temporal Logic (ICTL’97),
pages 91–106, 1997.
[KV99]
Orna Kupferman and Moshe Y. Vardi. Church’s problem revisited. The Bulletin
of Symbolic Logic, 5(2) :245–263, 1999.
[KV00]
Orna Kupferman and Moshe Y. Vardi. µ-calculus synthesis. In Mogens Nielsen
and Branislav Rovan, editors, Proceedings of the 25th International Symposium
on Mathematical Foundations of Computer Science (MFCS’00), volume 1893 of
Lecture Notes in Computer Science, pages 497–507. Springer, 2000.
[KV01]
Orna Kupferman and Moshe Y. Vardi. Synthesizing distributed systems. In
Joseph Y. Halpern, editor, Proceedings of the 16th IEEE Annual Symposium on
Logic in Computer Science (LICS’01). IEEE Computer Society Press, 2001.
[Ler05]
Benjamin Lerman.
Vérification et Spécification des Systèmes Distribués.
PhD thesis, Université Denis Diderot - Paris VII, Paris, France, 2005.
http://tel.archives-ouvertes.fr/tel-00322322/fr/.
[LT89]
Nancy Lynch and Mark R. Tuttle. An introduction to input/output automata.
CWI-Quarterly, 2(3) :219–246, 1989.
[Maz77]
Antoni Mazurkiewicz. Concurrent program schemes and their interpretations.
DAIMI report PB 78, Aarhus University, 1977.
[Maz86]
Antoni W. Mazurkiewicz. Trace theory. In Wilfried Brauer, Wolfgang Reisig, and
Grzegorz Rozenberg, editors, Petri Nets : Central Models and Their Properties,
Advances in Petri Nets 1986, Part II, Proceedings of an Advanced Course, Bad
Honnef, 8.-19. September 1986, volume 255 of Lecture Notes in Computer Science,
pages 279–324. Springer, 1986.
[MS87]
David E. Muller and Paul E. Schupp. Alternating automata on infinite trees.
Theoretical Computer Science, 54 :267–276, 1987.
152
[MS95]
[MT01]
[MT02a]
[MT02b]
[MTY05]
[MW80]
[MW84]
[MW03]
[MWZ09]
[Pnu77]
[PR79]
[PR89a]
BIBLIOGRAPHIE
David E. Muller and Paul E. Schupp. Simulating alternating tree automata by
nondeterministic automata : New results and new proofs of theorems of Rabin,
McNaughton and Safra. Theoretical Computer Science, 141(1&2) :69–107, 1995.
P. Madhusudan and P. S. Thiagarajan. Distributed controller synthesis for local specifications. In Fernando Orejas, Paul G. Spirakis, and Jan van Leeuwen,
editors, Proceedings of the 28th International Colloquium on Automata, Languages and Programming (ICALP’01), volume 2076 of Lecture Notes in Computer
Science, pages 396–407. Springer, 2001.
P. Madhusudan and P. S. Thiagarajan. Branching time controllers for discrete
event systems. Theoretical Computer Science, 274(1-2) :117–149, 2002. Concurrency theory (Nice, 1998).
P. Madhusudan and P. S. Thiagarajan. A decidable class of asynchronous distributed controllers. In Lubos Brim, Petr Jancar, Mojmı́r Kretı́nský, and Antonı́n
Kucera, editors, Proceedings of the 13th International Conference on Concurrency
Theory (CONCUR’02), volume 2421 of Lecture Notes in Computer Science, pages
145–160. Springer, 2002.
P. Madhusudan, P. S. Thiagarajan, and Shaofa Yang. The MSO theory of connectedly communicating processes. In Ramaswamy Ramanujam and Sandeep Sen,
editors, Proceedings of the 25th Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS’05), volume 3821 of Lecture
Notes in Computer Science, pages 201–212. Springer, 2005.
Zohar Manna and Richard J. Waldinger. A deductive approach to program synthesis. Association for Computing Machinery Transactions on Programming Languages and Systems, 2(1) :90–121, 1980.
Zohar Manna and Pierre Wolper. Synthesis of communicating processes from
temporal logic specifcations. ACM Transactions on Programming Languages and
Systems, 6(1) :68–93, 1984.
Swarup Mohalik and Igor Walukiewicz. Distributed games. In Paritosh K.
Pandya and Jaikumar Radhakrishnan, editors, Proceedings of the 23rd Conference on Foundations of Software Technology and Theoretical Computer Science
(FSTTCS’03), volume 2914 of Lecture Notes in Computer Science, pages 338–351.
Springer, 2003.
Anca Muscholl, Igor Walukiewicz, and Marc Zeitoun. A look at the control of
asynchronous automata. In Kamal Lodaya, Madhavan Mukund, and Ramanujam R., editors, Perspectives in Concurrency Theory, pages 356–371. Universities
Press, 2009.
Amir Pnueli. The temporal logic of programs. In Proceedings of the 18th Annual
IEEE Symposium on Foundations of Computer Science (FOCS’77), pages 46–57.
IEEE Computer Society Press, 1977.
Gary L. Peterson and John H. Reif. Multiple-person alternation. In Proceedings of the 20th Annual IEEE Symposium on Foundations of Computer Science
(FOCS’79), pages 348–363. IEEE Computer Society Press, 1979.
Amir Pnueli and Roni Rosner. On the synthesis of a reactive module. In Proceedings of the 16th Annual ACM Symposium on Principles of Programming Languages (POPL’89), pages 179–190. ACM, 1989.
BIBLIOGRAPHIE
153
[PR89b]
Amir Pnueli and Roni Rosner. On the synthesis of an asynchronous reactive
module. In Giorgio Ausiello, Mariangiola Dezani-Ciancaglini, and Simona Ronchi Della Rocca, editors, Proceedings of the 16th International Colloquium on Automata, Languages and Programming (ICALP’89), volume 372 of Lecture Notes
in Computer Science, pages 652–671. Springer, 1989.
[PR90]
Amir Pnueli and Roni Rosner. Distributed reactive systems are hard to synthesize.
In Proceedings of the 31st Annual IEEE Symposium on Foundations of Computer
Science (FOCS’90), volume II, pages 746–757. IEEE Computer Society Press,
1990.
[Pri67]
Arthur Prior. Past, Present and Future. Oxford University Press, 1967.
[Rab70]
Michael Oser Rabin. Weakly definable relations and special automata. In Y. BarHillel, editor, Proceedings of the Symposium of Mathematical Logic and Foundations of Set Theory, pages 1–23, 1970.
[Rab72]
Michael Oser Rabin. Automata on Infinite Objects and Church’s Problem. American Mathematical Society, 1972.
[RD95]
Grzegorz Rozenberg and Volker Diekert, editors. Book of Traces. World Scientific,
Singapore, 1995.
[Ric53]
Henry Gordon Rice. Classes of recursively enumerable sets and their decision
problems. Transactions of the American Mathematical Society, 74(2) :358–366,
1953.
[RLL04]
April Rasala Lehman and Eric Lehman. Complexity classification of network
information flow problems. In J. Ian Munro, editor, Proceedings of the 15th ACMSIAM Symposium on Discrete Algorithms (SODA’04), pages 142–150. Society for
Industrial and Applied Mathematics, 2004.
[Ros92]
Roni Rosner. Modular Synthesis of Reactive Systems. PhD thesis, Weizmann
Institute of Science, Rehovot, Israel, 1992.
[RW89]
P. J. G. Ramadge and W. M. Wonham. The control of discrete event systems. In
Proceedings of the IEEE, volume 77, pages 81–98. IEEE Press, 1989.
[Tho90]
Wolfgang Thomas. Automata on infinite objects. In Jan van Leeuwen, editor,
Handbook of Theoretical Computer Science : Volume B : Formal Models and Semantics, pages 133–191. Elsevier, 1990.
[Var95]
Moshe Y. Vardi. An automata-theoretic approach to fair realizability and synthesis. In Pierre Wolper, editor, Proceedings of the 7th International Conference on
Computer Aided Verification (CAV’95), volume 939 of Lecture Notes in Computer
Science, pages 267–278. Springer, 1995.
[vdMV98] Ron van der Meyden and Moshe Y. Vardi. Synthesis from knowledge-based specifications. In Davide Sangiorgi and Robert de Simone, editors, Proceedings of
the 9th International Conference on Concurrency Theory (CONCUR’98), volume
1466 of Lecture Notes in Computer Science, pages 34–49. Springer, 1998.
[vdMW05] Ron van der Meyden and Thomas Wilke. Synthesis of distributed systems
from knowledge-based specifications. In Martı́n Abadi and Luca de Alfaro, editors, Proceedings of the 16th International Conference on Concurrency Theory
(CONCUR’05), volume 3653 of Lecture Notes in Computer Science, pages 562–
576. Springer, 2005.
154
BIBLIOGRAPHIE
[VS85]
Moshe Y. Vardi and Larry J. Stockmeyer. Improved upper and lower bounds
for modal logics of programs : Preliminary report. In Proceedings of the 7th
Annual ACM Symposium on Theory of Computing (STOC’85), pages 240–251.
ACM Press, 1985.
[WTD91]
Howard Wong-Toi and David L. Dill. Synthesizing processes and schedulers from
temporal specifications. In Edmund M. Clarke and Robert P. Kurshan, editors,
Proceedings of the 2nd International Conference on Computer Aided Verification
(CAV’90), volume 531 of Lecture Notes in Computer Science, pages 272–281.
Springer, 1991.
[Zie87]
Wieslaw Zielonka. Notes on finite asynchronous automata. ITA, 21(2) :99–135,
1987.
[Zie95]
Wieslaw Zielonka. The book of traces, chapter 7 : Asynchronous Automata. World
Scientific, 1995.
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement