Algorithmes efficaces de recherche pour une machine chimique pair-à-pair

(1)

HAL Id: dumas-00725210

https://dumas.ccsd.cnrs.fr/dumas-00725210

Submitted on 24 Aug 2012

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Algorithmes eﬀicaces de recherche pour une machine

chimique pair-à-pair

Matthieu Perrin

To cite this version:

Matthieu Perrin. Algorithmes eﬀicaces de recherche pour une machine chimique pair-à-pair. Calcul parallèle, distribué et partagé [cs.DC]. 2012. �dumas-00725210�

(2)

Rapport de stage

master informatique sp´ecialit´e Recherche en informatique

Universit´e de Rennes I

Algorithmes efficaces de recherche pour une

machine chimique pair-`a-pair

Matthieu Perrin

´Ecole Normale Sup´erieure de Cachan, antenne de Bretagne matthieupierre.perrin@gmail.com

Stage réalisé de Février 2012 à Juin 2012

Supervis´e par

Marin Bertier C´edric Tedeschi

Maˆıtre de conférences Maˆıtre de conférences INSA de Rennes Université de Rennes I Équipe ASAP, IRISA, Équipe Myriads, IRISA,

INRIA Rennes Bretagne Atlantique INRIA Rennes Bretagne Atlantique Marin.Bertier@irisa.fr cedric.tedeschi@inria.fr

R´esum´e

La difficulté de la programmation des systèmes répartis à large échelle est encore aujourd’hui un frein à leur développement. Le paradigme chimique fournit une abstraction de haut niveau adaptée à la programmation de tels systèmes. Cependant, l’exécution de programmes

chimiques nécessite la recherche de tuples d’éléments d’un multi-ensemble vérifiant une certaine propriété. Le but de ce rapport est d’améliorer la complexité de cette opération.

Mots cl´es

(3)

Internship report

master of Computer Sciences speciality research in computer sciences

University of Rennes I

Efficient research algorithms for a peer-to-peer

chemical machine

Matthieu Perrin

´Ecole Normale Sup´erieure de Cachan, Brittany extension matthieupierre.perrin@gmail.com

Internship conducted from February 2012 to June 2012

Under the supervision of

Marin Bertier C´edric Tedeschi

Assistant professor Assistant professor INSA Rennes University of Rennes I ASAP teem, IRISA, Myriads teem, IRISA,

INRIA Rennes Bretagne Atlantique INRIA Rennes Bretagne Atlantique Marin.Bertier@irisa.fr cedric.tedeschi@inria.fr

Abstract

The difficulty of programming large scale distributed systems is still a limit for their developement. The chemical paradigm provides a high level abstraction appropriate to the programming of such systems. However, executing chemical programs requires being able to

find a tuple of elements satisfying a given property in a multiset. This report aims at presenting a new algorithm that improves the complexity of this operation.

Keywords

(4)

“Indeed, I believe that virtually every important aspect of programming arises somewhere in the context of sorting and searching !”

Donald E. Knuth,

(5)

Table des mati`eres

Introduction 5

1 La programmation chimique 6

1.1 Les mod`eles de la programmation chimique . . . 6

1.2 Programmer en chimique . . . 8

1.3 Les d´efis des machines chimiques . . . 9

2 Étude théorique 11 2.1 Formalisation de la recherche de réactions . . . 11

2.2 Carrure d’une r`egle . . . 15

2.3 Affectations . . . 18

2.4 Pr´esentation de l’algorithme . . . 21

3 Algorithme d´ecentralis´e 23 3.1 Construction de l’ensemble d’axiomes induits . . . 23

3.2 Recherche de r´eactifs . . . 28

3.3 D´etection de l’inertie . . . 32

Travaux futurs et conclusion 34 Pour aller plus loin . . . 34

Conclusion . . . 36

Remerciements . . . 36

(6)

Introduction

La construction de grosses applications réparties capables de s’adapter de façon au-tonome à l’évolution de leur environnement est encore aujourd’hui un travail de titans. L’hétérogénéité, la distribution géographique et les faibles garanties de fiabilité offertes par les ressources disponibles imposent une gestion fine des données, des messages et des res-sources de calcul afin de garantir des propriétées d’auto-organisation en une structure adaptée au problème, d’auto-adaptation en fonction de la variation de performance de constituants de la plate-forme au cours du temps, et d’auto-réparation pour contrer le manque de fiabilité des machines.

Pour répondre à ces difficultés, de nouveaux paradigmes de programmation doivent être pensés pour apporter des abstractions de haut niveau susceptibles de cacher la complexité inhérente aux réseaux hétérogènes, et donc simplifier la conception d’applications réparties.

Le paradigme de programmation chimique [4] permet de se représenter des calculs comme des réactions chimiques apparaissant de façon autonome et parallèle parmi les molécules de données afin de produire de nouvelles molécules de résultat. Exécuter des programmes chi-miques sur une plate-forme répartie revient à effectuer des réécritures sur un multi-ensemble contenant les molécules du calcul et distribué sur la plate-forme.

La construction d’un tel multi-ensemble dans une plate-forme dynamique pair-à-pair à large échelle a pour le moment seulement été initialisée, en se basant soit sur des tables de ha-chage distribuées [21, 19], soit sur des technologies de type gossip [11]. De nombreux problèmes restent cependant ouverts dans ce domaine. En particulier, la recherche d’un sous-ensemble de molécules satisfaisant la condition de réaction d’une règle est toujours basée sur une exploraa-tion exhaustive de toutes les combinaisons possibles de molécules, ce qui est particulièrement peu efficace, surtout pour les règles prenant beaucoup d’arguments.

La question que l’on s’est posé pendant ce stage concernait la possibilité d’améliorer le temps de recherche de réactifs pour des règles compliquées. La première partie de ce rapport expose plus en détail le principe de la programmation chimique. Nous étudierons en deuxième partie comment une étude des règles sous un aspect plus théorique permet d’optimiser la re-cherche de réactifs. En troisième partie, nous verrons comment les leçons de l’étude théoriques peuvent servir à créer une machine chimique répartie plus efficace. Enfin, nous terminerons par un exposé du travail qu’il reste à accomplir et nous concluerons.

(7)

Chapitre 1

La programmation chimique

Le but de ce chapitre est d’expliquer les principes de la programmation chimique. Nous verrons tout d’abord les principaux formalismes et langages basés sur ce paradigme, puis nous étudierons des exemples de programmes chimiques. Dans la dernière partie, nous entrerons plus dans les détails des problèmes posés par la mise en œuvre de la programmation chimique.

1.1 Les mod`eles de la programmation chimique

Dans un véritable système chimique, des molécules de toutes sortes entrent en contact et réagissent pour en former de nouvelles. Les règles qui régissent ces réactions sont à l’origine de la vie et de tout ce que l’on peut trouver sur Terre.

Le paradigme de la programmation chimique est basé sur une métaphore de cet aspect particulièrement productif de la nature. Les données à traiter y sont comparées à des molécules et les algorithmes à exécuter sont représentés comme des règles de réaction sur ces molécules. La chimie a inspiré de nombreux formalismes [9] utiles dans de nombreux domaines très différents. Nous allons maintenant brièvement présenter quelques-uns des plus importants dans le domaine de la programmation chimique.

Le modèle Γ. Un programme écrit en Γ [4, 15] est représenté par un couple (RΓ, AΓ) o ù RΓ

est la fonction booléenne des conditions de réactions, qui définit si n molécules peuvent réagir ou non, et AΓ est la fonction d’action, qui définit les produits des réactions. Un programme

peut être exécuté sur un multi-ensemble M , contenant les molécules à faire réagir.

L’exécution d’un programme s’apparente à une suite de réécritures du multi-ensemble. Tant qu’il existe des molécules dans M qui vérifient la condition de réaction, ils sont remplacés par le résultat de la fonction d’action, selon l’algorithme 1.

Le programme chimique est terminé lorsque plus aucune réaction n’est possible. On parle alors d’état d’inertie du système. La programmation chimique est non-déterministe, car l’ordre dans lequel deux réactions concurentes sont exécutées ne peut pas être prédit. Cela implique que l’unicité de l’état d’inertie, et donc du résultat du programme, ne peut être assurée que par le programmeur lui-même s’il souhaite que cette propriété soit vérifiée.

(8)

Algorithme 1: L’op´erateur Γ applique un programme (RΓ, AΓ) `a un multi-ensemble M Γ(RΓ, AΓ)(M ) : 1 if ∃x1,· · · , xn∈ M |RΓ(x1,· · · , xn) then 2 return Γ(RΓ, AΓ)(M − {x1,· · · , xn}) ∪ AΓ(x1,· · · , xn) 3 else 4 return M 5 end 6

Le γ-calcul. A l’instar du λ-calcul au regard de la programmation fonctionnelle, le γ-calcul` [6] est un syst`eme de calcul minimal d’ordre sup´erieur permettant de formaliser la program-mation chimique.

Un γ-terme est d´efini par la grammaire :

M ::= x variable

| (γ hxi .M ) γ−abstraction | (M1, M2) multi−ensemble

| hM i solution.

L’opérateur ≪,≫, associatif et commutatif permet d’énumérer les molécules, d’un

multi-ensemble. Certaines molécules particulières, les sous-soulutions, ont pour r ôle d’isoler des molécules du reste du multi-ensemble en formant des sous-solutions. Un γ-terme peut donc être vu comme une hiérarchie de solutions contenant des molécules.

En γ-calcul, les règles de réaction sont directement intégrées dans la solution sous la forme de molécules particulières, les γ-abstractions. Il devient ainsi possible d’utiliser l’ordre supérieur, qui permet de modifier le comportement du programme au cours du temps. Par exemple, une règle qui n’est plus utilisée peut être supprimée, ou à l’inverse de nouvelles règles peuvent être introduites.

Comme dans Γ, les réactions ont lieu jusqu’à ce que l’inertie soit atteinte. Une sous-solution inerte peut alors être utilisée par une règle comme n’importe quelle molécule.

Ce formalisme est Turing-complet, puisqu’il permet d’encoder le λ-calcul. Il est mˆeme plus expressif que ce dernier car il permet d’exprimer du non-d´eterminisme.

Le langage HOCL. HOCL [3] (pour Higher Order Chemical Language), est un langage utilisable basé sur le γ-calcul, mais étendu avec des types, des valeurs de base telles que les entiers, les booléens et les chaˆınes de caractères, ainsi que des expressions, des couples, la solution vide et la possibilité de nommer les molécules.

Une r`egle de HOCL est d´efinie par la syntaxe

replace x1 :: T1,· · · xn:: Tnby P (x1,· · · xn) if C(x1,· · · xn)

qui signifie que, si elles v´erifient la conditon C(x1,· · · xn), les mol´ecules x1,· · · xnde types

res-pectifs T1,· · · Tndoivent être supprimées du multi-ensemble et être remplacées par les valeurs

(9)

L’implémentation séquentielle du langage requiert une compilation les programmes HOCL en Java avant de les exécuter. Pour cette raison, toute fonction Java est acceptée pour P et les molécules peuvent être des instances de classes Java.

1.2 Programmer en chimique

Après avoir vu les principaux formalismes et langages de programmation du paradigme chimique, nous allons illustrer l’expressivité du paradigme grâce à quelques exemples.

Un exemple simple. L’algorithme 2, qui calcule le plus grand nombre pair d’un multi-ensemble, utilise tous les principaux aspects de HOCL.

Algorithme 2: Calcul du plus grand ´el´ement pair en HOCL let getEvens = replace x :: int by if x%2! = 0 in

1

let getM ax = replace x :: int, y :: int by x if x ≥ y in

2

let replaceRule = replace-one hgetEvens, ?ωi by hgetM ax, ωi in

3

let clean = replace-one hgetM ax, ?ωi by ω in

4

hreplaceRule, clean, hgetEvens, 2, 3, 5, 6, 8, 9ii

5

Initialement, la sous-solution n’est pas inerte. Seule la règle getEvens, qui supprime tous les nombres impairs, peut réagir pour arriver à l’état hreplaceRule, clean, hgetEvens, 2, 6, 8ii, dans lequel la sous-solution est inerte. La règle replaceRule peut alors réagir, donnant l’état hclean, hgetM ax, 2, 6, 8ii, qui réagit pour donner le résultat hclean, hgetM ax, 8ii, puis h8i, qui est bien le plus grand nombre pair parmi ceux initialement dans le multi-ensemble.

Autres exemples. L’article [5] ouvre de nombreuses pistes pour impl´ementer des algorithmes de traitement de chaˆınes de caract`eres ou d’images ou de recherche du plus court chemin dans un graphe dans un contexte chimique.

Par ailleurs, le paradigme chimique se montre bien adapté à la spécification des appli-cations décentralisées. Nous avons choisi deux exemples qui montrent des domaines o ù la programmation chimique a permis d’apporter un nouveau regard ces dernières années.

Un système informatique est dit autonome [17] s’il est capable de s’auto-organiser en res-pectant des propriétés définies à l’avance. Ces systèmes s’occupent de leur propre compor-tement sans intervention extérieure. La principale difficulté de conception d’un tel système vient de la transformation des propriétés que l’on cherche à garantir en algorithmes réels. La programmation chimique peut être utilisée pour spécifier [5], et même implémenter [2] de tels systèmes.

L’Internet des services a pendant longtemps été considéré comme le futur d’Inter-net, mais l’absence de moyens simples et décentralisés pour gérer la composition de ser-vices en a empêché le grand développement prévu. Dans ce domaine, on a besoin de répondre à certains challenges injectant des propriétés d’auto-organisation, d’auto-adaptation et d’auto-réparation, voire d’auto-optimisation. Pour cela, le modèle chimique, possédant in-trinsèquement ces qualités, est prometteur. En particulier, il a récement été montré [12] que le

(10)

paradigme chimique pouvait être utilisé pour coordonner les services de manière totalement décentralisée.

1.3 Les d´efis des machines chimiques

Le paradigme chimique offre de nouveaux horizons à l’inventivité des développeurs grâce à des concepts simples et puissants. En principe, la recherche de réactions est largement pa-rallélisable, en raison de la propriété de localité : aucune propriété d’ensemble ne peut être demandée sur le multi-ensemble en entier dans une condition de réaction. Il reste pourtant des problèmes ouverts à résoudre pour avoir une machine chimique complète.

Exécution d’un programme chimique. L’algorithme général (algorithme 3), adapté des ar-ticles [5, 9] qui présentent une solution générale à la chimie artificielle, est composé d’une boucle de recherche de molécules du multi-ensemble P pouvant réagir ensemble. Lorsque de telles molécules sont découvertes, elles sont remplacées par le produit de leur réaction.

Algorithme 3: Algorithme général d’exécution d’un programme chimique while ¬Inert(P ) do 1 if ∃ (r =replace x1,· · · xnby y1,· · · ymif f (x1,· · · xn)) , x1,· · · xn∈ P s.t.f (x1,· · · , xn) 2 then P :=remove(P, x1,· · · xn); 3 P :=insert(P, y1,· · · ym); 4

Plusieurs processus qui partagent le même multi-ensemble de molécules peuvent exécuter cet algorithme en parallèle. Cela pose trois sous-problèmes.

– L’algorithme s’arrête lorsque la solution est inerte. En HOCL, cette situation d’inertie est atteinte quand toutes les conditions de réaction ne sont vérifiées par aucun tuple de molécules. Comme nous le verrons dans la partie 2.1, décider si une solution est inerte est un problème algorithmiquement difficile.

– Trouver les réactions possibles dans le multi-ensemble est le problème dual du précédent, puisque la terminaison est assurée si et seulement si aucune réaction n’est possible. Cependant, séparer les deux sous-problèmes peut être pratique dans le cas d’un calcul parallèle car il est possible qu’à un instant donné, aucune réaction ne soit possible dans un processus en raison de verrouillages de certaines molécules par d’autres proces-sus, sans que la réaction soit terminée pour autant.

– Le dernier problème est la modification du multi-ensemble. À chaque itération de l’algo-rithme, des molécules sont retirées de la solution et d’autres y sont ajoutées de manière atomique.

Un algorithme de capture atomique. La capture atomique de molécules peut être vu comme un problème de synchronisation entre des processus dans lequel la propriété de vivacité est que si plusieurs processus cherchent à effectuer une réaction, au moins l’un d’eux pourra la faire. L’article [7] propose un algorithme basé sur deux protocoles. L’un, dit optimiste, est conçu pour minimiser l’utilisation du réseau en abandonnant une réaction dès que l’un des réactifs qu’il envisageait pour sa réaction est également prisé par un autre pair. Dans un système dans

(11)

lequel beaucoup de réactions sont possibles, la probabilité qu’un réactif soit prisé par plusieurs pairs est faible, donc un pair optimiste garde l’espoir de pouvoir exécuter des réactions. Un système de commutation permet de toujours choisir l’algorithme le plus avantageux des deux. Recherche de molécules dans un multi-ensemble. La recherche de molécules pouvant réagir dans le multi-ensemble est très proche du problème DisCSP [8] qui est presque tou-jours traité par une exploration exhaustive des nœuds du réseau, avec éventuellement une optimisation grâce au back-tracking [10, 22].

Naturellement, la recherche de molécules est donc également toujours traitée par une re-cherche exhaustive. On peut citer par exemple un algorithme utilisant une mémoire partagée entre les cœurs de calcul [14], ou un système regroupant les molécules en sacs dans lesquels tous les tests ont été effectués [16].

Nous pouvons enfin présenter les travaux réalisés dans [18], qui se basent sur un réseau pair-à-pair non structuré et des protocoles épidémiques pour modéliser le mouvement brow-nien naturellement présent dans une solution chimique réelle. Cependant, ce travail ne cherche pas à détecter l’inertie, ce qui rend l’approche incomplète.

Ainsi, pour savoir si une solution contenant n molécules et une règle d’arité k est inerte, tous ces algorithmes testeront toutes les combinaisons de k molécules, parmi les n possibles.

Ce qu’il ressort de cette analyse est la difficulté de trouver des algorithmes efficaces pour la recherche de réactifs dans une solution chimique. [16] fait même le postulat que la complexité en

n k

qu’ils atteignent est une limite optimale. Nous nous proposons dans la suite du rapport d’´etudier le bien-fond´e de cette assertion.

(12)

Chapitre 2

´Etude th´eorique

Nous venons de voir combien le pardigme chimique était prometteur en terme d’expres-sivité et d’adaptation aux problèmes habituels de l’algorithmique répartie. Des systèmes au-tonomes à la programmation de l’internet des services, la programmation chimique simplifie de nombreux problèmes apparamment très complexes. Derrière la simplicité du paradigme se cache pourtant un grand problème : comment trouver des molécules capables de réagir entre elles, ou, à l’inverse, comment montrer que plus aucune réaction n’est possible dans la solu-tion ? À cette question, toutes les implémentations actuelles du langage se résignent à tester toutes les combinaisons imaginables de molécules, impliquant une complexité

n k ∼ n≫kn k

pour n molécules et une règle d’arité k. Dans ce chapitre, nous allons chercher à comprendre ce qui rend la recherche de réactions aussi compliqué, et en déduire un nouvel algorithme plus efficace.

2.1 Formalisation de la recherche de r´eactions

Le problème que l’on cherche à résoudre dans cette partie est la recherche de réactifs dans une réaction chimique. Plus précisément, on se place dans un contexte plus proche de Γ pour concevoir un algorithme prenant comme entrée :

– une r`egle chimique R = replace x1 :: T1,· · · , xk :: Tkby F (x1,· · · , xk) if C(x1,· · · , xk)

et

– un multi-ensemble M de mol´ecules ; et en sortie :

– ⊥ si M ∪ hRi est inerte,

– un k-uplet (m1,· · · mk) o `u {m1,· · · mk} ⊂ M , le type de mi est Ti pour tout i et

C(m1,· · · , mk) est v´erifi´ee, sinon.

On voit ici que la définition du résultat que l’on cherche à obtenir ne fait pas référence aux produits de la règle, qui n’entrent effectivement pas en compte dans la recherche de réactifs. Aussi, à partir de maintenant, nous désignerons la règle précédente par

R= find x1 :: T1,· · · , xk:: Tksuch that C(x1,· · · , xk).

S’il n’y avait pas de condition de réaction, le problème serait simple à résoudre, puisqu’il suffirait de comparer le nombre de molécules disponibles pour chaque type au nombre de

(13)

molécules demandées. C’est donc sur l’étude de cette condition que va porter l’essentiel de la suite de ce rapport.

Réduction du problème aux conjonctions de littéraux. Cette condition de réaction est une formule de la logique propositionnelle, dont les littéraux sont l’application d’une fonction booléenne aux variables x1 à xk. La définition de ces littéraux est laissée très libre, puisque

certaines implémentations du langage autorisent toutes les expressions Java, ce qui rend le problème de la recherche de réactifs en théorie indécidable. L’évaluation de code Java étant très éloigné du sujet de ce rapport, nous faisons l’hypothèse que l’évaluation des conditions de réaction termine, et nous évaluerons les complexités en fonction du nombre d’évaluations d’une partie de celle ci.

Comme toute formule propositionnelle, une condition de réaction peut être mise sous forme normale disjonctive. On peut encore simplifier la formule pour ne garder qu’un seul littéral par sous-ensemble de variables dans chaque terme en remplaçant :

– ¬f (x1,· · · , xp) par (¬f )(x1,· · · , xp),

– f1(x1,· · · , xp) ∧ f2(x1,· · · , xp) par (f1∧ f2)(x1,· · · , xp), ou plus g´en´eralement si l’un des

deux ensembles de variables concern´es est inclus dans l’autre.

En outre, le type d’une molécule peut être vu comme une condition sur cette molécule. Notre formule est alors de la forme :

R= find x1,· · · , xksuch that M _ i=1 ^ X∈Qk_j=1{ε,xj} fi,X(X).

Dans cette écriture, les X doivent être vus comme des sous-ensemble deux à deux disjoints des variables.

Les différents termes de la disjonction peuvent faire l’objet d’une recherche séparée, puisque la règle find x1,· · · , xk such that C1(x1,· · · , xk) ∨ C2(x1,· · · , xk) peut s’appliquer

à des molécules x1,· · · , xk si et seulement si C1(x1,· · · , xk) ∨ C2(x1,· · · , xk) c’est à dire

si et seulement si C1(x1,· · · , xk) ou C2(x1,· · · , xk), soit si et seulement si l’une des r`egles

find x1,· · · , xksuch that C1(x1,· · · , xk) ou find x1,· · · , xksuch that C2(x1,· · · , xk) peut

s’ap-pliquer. La règle R est donc équivalente à l’ensemble de règles :

M [ i=1     

Ri= find x1,· · · , xksuch that

^ X∈Qk j=1{ε,xj} fi,X(X)     

Le nombre M de formules générées est potentiellement exponentiel par rapport à k. Ce-pendant, en pratique :

– k est souvent de taille raisonnable, et est ind´ependant du multi-ensemble ;

– le passage à l’exponentielle ne concerne pas toutes les formules, mais seulement celles pour lesquelles la recherche est théoriquement difficile, comme les formules SAT ; – la recherche peut être faite de manière complètement parallèle.

`

A partir de maintenant, nous pouvons restreindre l’analyse à des règles de cette forme, que nous résumerons en R = find x1,· · · , xksuch that f1(X1) ∧ · · · ∧ fl(Xl).

Notations et définitions. Sur ces considérations, nous allons maintenant nous abstraire du problème. Considérons les ensembles suivants :

(14)

– V un ensemble dénombrable de symboles, appelés variables ; – M un ensemble dénombrable de molécules ;

– S l’ensemble des multi-ensembles finis de mol´ecules, appel´es solutions ; – F =T

n∈N(Mn7→ B) l’ensemble des fonctions bool´eennes sur des tuples de mol´ecules ;

– P = F × P(V) (o ù P représente l’ensemble des parties) l’ensemble des prédicats. Un littéral f (x1,· · · , xp) dans une règle peut être représenté comme un prédicat

(f, {x1,· · · , xp}). Étant donné un prédicat p = (f, E) ∈ P, on note F(p) = f et

arg(p) = E ;

– A = F × P(V × M) l’ensemble des propositions, qui sont l’équivalent des prédicats pour les molécules. Une proposition a = (f, {(x1, m1), ..., (xk, mk)}) ∈ A est appelée

axiome si f (m1, ..., mk) est vraie. On notera F(a) = f , arg(a) = {x1, ..., xk}, a(xi) = mi et

M(a) = {m1, ..., mk}. Par extension, si A ⊂ A, on notera M(A) =S_a∈AM(A) ;

– R = P(V) × P(P) l’ensemble des r`egles. Une r`egle

replace x1,· · · , xkby Y if f1(x1,1· · · , x1,a1) ∧ ... ∧ fl(xl,1· · · , xl,al)

sera repr´esent´ee dans ce formalisme par le couple

({x1,· · · , xk} , {(f1,{x1,1,· · · , x1,a1}) , · · · , (fl,{xl,1,· · · , xl,al})}) .

Pour R = (V, P ) ∈ R, on d´efinit les accesseurs V(R) = V et P(R) = P .

Le lecteur attentif aura remarqué l’utilisation de la lettre A, initiale du mot axiome, pour désigner l’ensemble des propositions. Comme nous cherchons à vérifier les conditions de réactions, seuls les axiomes que l’on peut tirer d’une solution nous intéressent réellement. Définition (ensemble d’axiomes induits). Pour une solution S ∈ S et une règle R ∈ R, on définit l’ensemble des axiomes induits par R dans S comme l’ensemble des axiomes dont les molécules sont dans S et satisfont un prédicat de R :

A(R, S) =(F(p), {(xi, mi) : xi ∈ arg(p) ∧ mi∈ S}) : p ∈ P(R) ∧ F(p) m1, ..., m|arg(p)|

(2.1) On peut remarquer une certaine correspondance entre le monde des règles et le monde des solutions. Les éléments de base sont les variables pour les règles et les molécules pour les solutions, et les éléments de la logique sont les prédicats dans le monde des règles et les pro-positions dans le monde des solutions. Pour cette raison, on donne ci-dessous deux définitions de la satisfaction d’un élément du monde des règles par un élément de celui des molécules. Définition(satisfaction d’un prédicat). Soient p ∈ P et a ∈ A, on dit que a satisfait p, et on note a|= p, si les trois conditions suivantes sont réunies :

– a est un axiome, – F(a) = F(p), – arg(a) = arg(p).

Définition(satisfaction d’une variable). Soient P ⊂ P, x ∈ V, A ⊂ A et m ∈ M. On dit que m satisfait x dans A, et on écrit (A, m) |= (P, x), ou simplement m |= x s’il n’y a pas d’ambigu¨ıté si

∀p ∈ P, x ∈ arg(p) ⇒ ∃a ∈ A, (x ∈ arg(a) ∧ a(x) = m ∧ a |= p). (2.2) Moins formellement, une molécule ne satisfait pas une variable si l’on sait qu’il est impossible qu’elle soit affectée à cette variable dans une réaction, par exemple si elle n’est pas du bon type.

(15)

Étude de la complexité intrinsèque du problème. Sous l’hypothèse de terminaison de l’évaluation des conditions de réaction — en un temps alors nécessairement indépendant de n et k — le problème de la recherche de réactifs est de classe NP, puisque faire tous les tests entre des molécules de manière non-déterministe permet de le résoudre en temps polynomial. Nous allons donc étudier la NP-difficulté du problème, qui n’avait jamais été formellement établie. Définition(rang d’une règle). On appelle rang d’une règle R la plus grande arité des prédicats de R :

rg(R) = max

p∈P(R)| arg(p)|. (2.3)

Pour tout n, on appelle Rnl’ensemble des règles de rang inférieur ou égal à n.

En programmation chimique, la grande majorité des règles que l’on peut trouver sont de rang 1 ou 2. Il est pourtant possible de créer des règles de rang supérieur, comme par exemple la règle de rang k :

N ulSumk= find x1· · · xksuch that k

X

i=1

xi = 0

Une autre façon de créer de telles règles est d’utiliser l’interface entre Java et HOCL pour utiliser des méthodes de Java à plusieurs arguments dans un programme chimique.

Propriété 1 (difficulté par rapport au rang). Le problème de la recherche de réactifs est

NP-difficile en fonction du rang de la r`egle.

D´emonstration. Remarquons que la recherche de n mol´ecules dont la somme s’annule est un

problème difficile. En effet, il rappelle le fameux problème NP-complet de la somme de sous-ensembles : étant donné un ensemble d’entiers E de taille n, existe-t-il un sous-ensemble de Edont la somme des éléments est nulle ? Supposons que l’on soit capable de savoir s’il existe kmolécules de somme 0 dans une solution de taille n en un temps inférieur à a.np_{, o ù a est}

un réel positif et p est indépendant de k. Alors si l’on effectue le test pour tous les 1 ≤ k ≤ n sur l’ensemble E, on peut résoudre le problème de la somme de sous-ensembles en un temps inférieur à a.np+1, c’est à dire polynomial. On a donc bien réussi à ramener la recherche de réactifs pour la règle N ulSumk à celui de la somme de sous-ensembles, ce qui prouve bien

notre propri´et´e.

Il risque donc d’être difficile de trouver un algorithme plus efficace que |S|rg(R)dans le pire cas. Nous pouvons cependant chercher à améliorer la recherche dans les cas o ù le rang d’une règle est inférieur à son arité.

Comme nous l’avons signalé précédement, la plupart des règles de programmes réels en HOCL appartiennent à R2. Cet ensemble peut être vu comme celui des graphes dont les

som-mets sont les variables et les arêtes sont les prédicats. Nous réutiliserons donc naturellement des termes et des notations sur les règles héritées de la théorie des graphes, que nous étendrons aux règles de rang quelconque.

Définition(sous-règle). Soient R1, R2 ∈ R. On dit que la règle R1est une sous-règle de R2, noté

R1 ⊂ R2, si V(R1) ⊂ V(R2) et P(R1) ⊂ P(R2).

Définition(connexité). On dit qu’une règle R est connexe si

∀x, y ∈ V(R), ∃x1,· · · , xn∈ V(R), x1 = x ∧ xn= y ∧ (∀i, ∃p ∈ P(R), {xi, xi+1} ⊂ arg(p)). (2.4)

(16)

D´efinition(clique). On dit qu’une r`egle R est une clique si

∀x, y ∈ V(R), ∃p ∈ P(R), {x, y} ⊂ arg(p). (2.5) Dans le cas de règles de rang 2, l’ensemble des axiomes induits peut également être vu comme un graphe dans lequel les nœuds sont les molécules, et les arêtes sont les axiomes. Trouver des réactifs revient à rechercher un sous-graphe isomorphe à celui de la règle dans le graphe des axiomes. Or ce problème est lui aussi connu comme NP-complet, parce qu’il contient le problème de la recherche de cliques.

Propriété 2(NP-difficulté pour le rang 2). Le problème de la recherche de réactifs est NP-difficile, en

fonction de son arit´e, pour une r`egle de rang 2.

D´emonstration. Supposons que l’on connaisse un algorithme polynomial en k pour la recherche

de r´eactifs pour toute r`egle de rang 2.

Soit un graphe G = (V, E). On veut savoir s’il existe un sous graphe de G de k nœuds qui est une clique. On crée le programme chimique dans lequel les molécules sont les nœuds de G et l’unique règle cherche k molécules toutes reliées les unes aux autres dans G :

*

find x1,· · · , xksuch that k−1 ^ i=1 k ^ j=i+1 (xi, xj) ∈ E, n ∈ V +

Selon notre hypothèse, ce programme chimique trouve une clique dans G en temps polyno-mial. On a bien réduit notre problème à celui de la recherche de cliques dans un graphe, ce qui montre la propriété.

La règle utilisée pour montrer la propriété 2 est une clique, c’est à dire une règle compliquée puisque sa condition de réaction possède autant de littéraux qu’il y a de couples de variables. Il faudrait donc trouver une façon de caractériser la complexité d’une règle. C’est ce que nous faisons dans la partie suivante, qui définit la carrure d’une règle.

2.2 Carrure d’une r`egle

Nous venons d’être confrontés à deux résultats négatifs qui peuvent donner une vision pessimiste de la difficulté du problème. Pourtant, la plupart des règles chimiques ne sont ni des cliques, ni de rang très élevé. Il nous manque une notion de complexité d’une règle pour identifier ce qui peut rendre la recherche compliquée. Dans cette partie, nous introduisons la carrure d’une règle comme une mesure de cette complexité.

Définition(jointure d’une règle). On considère que les variables d’une règle sont totalement triés selon une relation d’ordre ⋖. On définit la jointure J⋖(R) de R selon l’ordre ⋖ comme

l’ensemble des variables qui ont plusieurs voisines plus petites qu’elles :

J⋖(R) = {x ∈ V(R) : |{p ∈ P(R) : ∃y ⋖ x, {x, y} ⊂ arg(p)}| ≥ 2} . (2.6)

Définition(carrure d’une règle). La carrure d’une règle est la taille de sa plus petite jointure par rapport à tous les ordres possibles sur les règles.

C(R) = min

⋖ |J⋖(R)|.

(17)

1 ւ ց 2 ↓ 3 ց ւ 4 2 5 ւ ց ւ ց 1 7 4 ց ր ց ւ 3 6 2 ր ց 1 5 ւ ց ւ ց 3 8 6 ց ր ց ւ 4 9 ց ր 7

FIGURE2.1 – le pont, le huit et le treillis avec leur jointure minimale

Remarque. Trouver une jointure minimale de fac¸on efficace est un probl`eme toujours ouvert.

Cependant, celui-ci ne concerne que la règle elle-même, indépendament du reste du multi-ensemble. Ce calcul peut donc être réalisé à la compilation, et sa complexité n’influence pas le temps de recherche des réactifs.

Exemples. La carrure d’un arbre est nulle. En effet, par définition, chaque élément d’un arbre possède un unique père, sauf la racine qui n’en a pas du tout. Par conséquent, en suivant l’ordre topologique, on ne trouve aucun nœud dans la jointure.

La carrure d’un cycle vaut 1 car, quel que soit l’ordre que l’on choisit, le plus grand élément a comme pères son prédécesseur et son successeur.

Comme autres exemples de graphes, on peut citer le pont et le huit qui ont une carrure de 1, et le treillis qui a une carrure de 2 (voir figure 2.1).

Propriétés de la carrure. La carrure a été introduite comme une mesure de la complexité d’une règle. Nous allons maintenant montrer quelques bornes sur la carrure.

Propriété 3(croissance de C). Pour toutes règles R1et R2, si R1 ⊂ R2, alors C(R1) ≤ C(R2).

(18)

de P(R2) \ P(R1) un par un, puis ceux de V(R2) \ V(R1) pour arriver `a R1 depuis R2. On

commencera donc par une r´ecurrence sur |P(R2)| − |P(R1)|, puis on montrera que l’on peut

enlever simplement les variables non-contraintes.

Supposons V(R1) = V(R2). Si |P(R2)| − |P(R1)| = 0, on a R1 = R2 donc C(R1) = C(R2).

On suppose maintenant qu’il existe un n ≥ 0 tel que pour toutes r`egles R′1 et R′2 v´erifiant

V(R′₁) = V(R′₂) = V , P(R′₂) ⊂ P(R′₁) et |P(R′₂)| − |P(R′₁)| = n, on a C(R₁′) ≤ C(R′₂). Soient R1 et R2 v´erifiant P(R1) ⊂ P(R2) et |P(R2)| − |P(R1)| = n + 1. Soit p ∈ P(R2) \ P(R1). On

consid`ere la r`egle R telle que V(R) = V et P(R) = P(R1) ∪ {(f, A)}. On a |P(R2)| − |P(R)| = n

donc par hypoth`ese de r´ecurrence, C(R) ≤ C(R2).

Soit un ordre ⋖ sur les variables tel que J⋖(R) soit minimale. Pour tout x ∈ V ,

{p ∈ V : ∃y ⋖ x, {x, y} ⊂ arg(p)} ⊂ {p ∈ P(R) : ∃y ⋖ x, {x, y} ⊂ arg(p)} , donc J⋖(R1) ⊂ J⋖(R), et donc C(R1) ≤ |J⋖(R1)| ≤ |J⋖(R)| = C(R) ≤ C(R2).

D’après le principe d’induction, on peut en déduire que pour toutes règles R1 ⊂ R2

poss´edant les mˆemes variables, C(R1) ≤ C(R2).

On consid`ere maintenant la suppression des variables. Soient R1 et R2 tels que P(R1) =

P(R2) = F et V(R1) ⊂ V(R2). Quel que soit l’ordre ⋖ consid´er´e, pour toute variable x ∈

V(R2) \ V(R1), |{p ∈ V : ∃y ⋖ x, {x, y} ⊂ arg(p)}| = 0, donc J⋖(R1) = J⋖(R2), donc C(R1) =

C(R2).

Pour conclure avec des r`egles quelconques R1⊂ R2, on a bien

C(R1) = C(V(R2), P(R1)) ≤ C(R2).

Essayons de comparer la carrure d’une règle à son arité. Ici encore, le cas des règles de rang 2 est intéressant pour commencer.

Théorème 1(carrure d’une règle de R2). Soit une R une règle de rang 2. Alors

C(R) + rg(R) ≤ |V(R)|

et l’´egalit´e est atteinte si et seulement si R est une clique.

D´emonstration. Soient R une r`egle de rang 2, et ⋖ un ordre sur V(R). Les deux plus petites

variables x et y ont au plus 1 voisin sup´erieur. Par cons´equent, ils ne font pas partie de J⋖(R),

donc C(R) ≤ |V(R)| − 2 = |V(R)| − rg(R).

Si R est une clique, toute variable z diff´erente de x et y a comme voisin sup´erieur au moins xet y, donc z ∈ J⋖(R), et |J⋖(R)| = |V(R)| − rg(R), donc C(R) = |V(R)| − rg(R).

Si au contraire R n’est pas une clique, alors il existe x et y qui ne sont pas reliés. Considérons R′une clique dans laquelle on a supprimé le lien entre x et y. Alors R est une sous-règle de R′. Soit z une variable différente de x et y, et un ordre selon lequel les trois plus grands éléments sont z ⋖ x ⋖ y dans cet ordre. Alors J⋖(R′) = k − 3. On en déduit C(R) ≤ C(R′) ≤ k − 3.

Pour une règle de rang supérieur, cette propriété est fausse, et on n’a même pas C(R) ≤ |V(R)| − 2. Cela est d û au fait que deux variables peuvent être reliés par plusieurs prédicats.

(19)

FIGURE2.2 – Graphe d’une r`egle de rang 3 et de carrure 3

On peut prendre l’exemple de la règle suivante, dont le graphe est représenté sur la figure 2.2 : find x, y, z, t such that f (x, y, z) ∧ g(x, y, t) ∧ h(x, z, t) ∧ i(y, z, t).

On remarque que cette règle à 4 arguments est de carrure 3, ce qui entre en contradiction avec le théorème 1. Cela montre que dans le cas de règles de rang supérieur, il est nécessaire d’assouplir ce théorème en utilisant la notion d’équivalence de règles.

Définition( Équivalence de règles). On définit ≡ comme la plus petite relation d’équivalence sur les règles vérifiant :

∀R ∈ R, P(R) = {(f1, E1), (f2, E2)} ∪ P ⇒ R ≡ (V(R), {(f1∧ f2, E1∪ E2)} ∪ P ).

Autrement dit, deux règles sont équivalents si elles correspondent à la même règle du pro-gramme chimique, mais que le découpage de la condition de réaction en littéraux a été faite différement.

Théorème 2(borne sur C). Pour toute règle R, il existe une règle R′ ≡ R telle que C(R′) + rg(R′) ≤ |V(R′)|.

Démonstration. Soient une règle R et ⋖ un ordre sur V(R). Considérons R′ =

V(R),nV

f∈P(R)f

o

≡ R. Une seule fonction est pr´esente, donc la carrure est nulle. Or rg(R′) ≤ |V(R′)| , donc C(R′) + rg(R′) ≤ |V(R′)|.

Remarque. La règle R′ici définie n’est généralement pas celle qui minimise C(R′) + rg(R′). Elle est simplement donnée à titre d’illustration.

2.3 Affectations

Dans la partie précédente, nous avons défini une notion de complexité des règles. Pour les règles de rang 2, nous avons pu voir le lien qui unissait la carrure, les cliques et l’arité d’une règle. Il reste à présent à voir comment on peut tirer parti de cette nouvelle notion en pratique.

(20)

D´efinition(ensemble pur d’axiomes). Soient P ⊂ P et A ⊂ A. On dit que A est pur au regard de P si

∀m ∈ M(A), ∃x ∈ V, (A, m) |= (P, x) (2.7)

D´efinition(affectation). Soient A ⊂ A, P ⊂ P, x1,· · · , xp ∈ V et m1,· · · , mp ∈ M. On appelle

affectation de m1,· · · , mp à x1,· · · , xp, noté A[x1 := m1,· · · , xp := mp], la réunion de tous les

sous-ensembles purs au regard de P de {a ∈ A : ∀i, xi ∈ arg(a) ⇒ a(xi) = mi}.

Propriété 4(caractérisation de l’affectation). A′ = A[x1 := m1,· · · , xp := mp] est le plus grand

sous-ensemble pur de A, au sens de l’inclusion, v´erifiant ∀1 ≤ i ≤ p, (A′, m) |= (P, xi) ⇒ m = mi.

Démonstration. Trois choses sont à démontrer dans cette propriété :

– la puret´e de l’affectation,

– la propri´et´e ∀i, m |= xi ⇒ m = mi,

– et le fait que ce soit le plus grand tel ensemble.

Notons B = {a ∈ A : ∀i, xi∈ arg(a) ⇒ a(xi) = mi} l’ensemble qui a servi `a d´efinir

l’affecta-tion.

Soient A1et A2deux sous-ensembles purs de B. Soit m ∈ M(A1∪ A2) = M(A1) ∪ M(A2).

Si m ∈ M(A1), ∃x ∈ V, (A1, m) |= (P, x), donc ∃x ∈ V, (A1∪ A1, m) |= (P, x). On a le mˆeme

r´esultat si m ∈ M(A2). On en d´eduit que A1∪A2est pur. Comme le nombre de sous-ensembles

de B est fini, on peut en d´eduire que A est pur.

De plus, A′ ⊂ B. Par cons´equent, ∀i, ∀a, xi ∈ arg(a) ⇒ a(xi) = mi, donc ∀i, m |= xi⇒ m =

mi.

Enfin, soit A′′ un sous-ensemble pur de A v´erifiant ∀i, m |= xi ⇒ m = mi. Alors A′′est un

sous-ensemble pur de B. Donc par d´efinition de l’affectation, A′′ ⊂ A′.

Propri´et´e 5(Calcul de l’affectation). L’algorithme 4 retourne A[x1 := m1,· · · , xn:= mn].

Algorithme 4: Calcul de A[x1 := m1,· · · , xn:= mn]

A′← {a ∈ A : ∀i, xi ∈ arg(a) ⇒ a(xi) = mi};

1

repeat /* Computes a biggest fix point */

2

removed ← {a ∈ A′: ∃x ∈ arg(a), a(x) 6|= x};

3

A′ ← A′_{\ removed ; /* Remove the points that cannot be in A[· · · ] */}

4

until removed = ∅;

5

return A′

6

Démonstration. Montrons tout d’abord qu’à chaque itération de la boucle,

A′[x1 := m1,· · · , xp := mp] demeure inchang´e. Soient A1 = A′[x1 := m1,· · · , xp := mp] et

A2 = (A′\removed)[x1 := m1,· · · , xp:= mp]. On a A2 ⊂ A1par construction. R´eciproquement,

soit B un sous-ensemble pur de A1. Comme B est pur, removed ∩ B = ∅, donc B ⊂ A2. Par

cons´equent, la r´eunion de tels B est identique, donc A1 = A2.

Soit B la valeur retournée par l’algorithme 4. On peut déduire du paragraphe précédent que B[x1 := m1,· · · , xp := mp] = A[x1 := m1,· · · , xp := mp]. Or, si B n’était pas pur, par

définition de la pureté, ∃m ∈ M(B), ∀x ∈ V, m 6|= x. Cette molécule apparait dans une certaine propriété a avec une certaine variable x, donc ∃a ∈ B, ∃x ∈ arg(a), a(x) 6|= x. Mais alors lors

(21)

de la dernière itération, ce a doit être mis dans removed. Cela est absurde puisque removed = ∅ lors de la dernière itération. Par conséquent, B est pur, donc

B = B[x1 := m1,· · · , xn:= mn] = A[x1:= m1,· · · , xn:= mn]

et l’algorithme est correct.

Les deux propriétés suivantes, qui manipulent l’arithmétique des affectations, montrent la souplesse du calcul sur les affectations. Elles introduisent également A[ ], appelé l’épuré de A ou l’affectation vide, qui est le plus grand sous-ensemble pur de A.

Propriété 6(Séparation des variables affectées). Si X désigne≪x₁ := m₁,· · · , x_x := m_x≫et Y

d´esigne≪y₁ := n₁,· · · , y_y := n_y≫, on a A[X, Y ] = A[X][Y ] = A[Y ][X] = (A[X] ∩ A[Y ])[ ].

D´emonstration. Soit A′ ⊂ A pur. Les conditions suivantes sont ´equivalentes : (m |= xi ⇒ m = mi) ∧ (n |= yi ⇒ n = ni) s.s.i. A′ ⊂ A[X, Y ]

s.s.i. (A′ _{⊂ A[X]) ∧ (n |= y}

i⇒ n = ni) s.s.i. A′ ⊂ A[X][Y ]

s.s.i.

(A′ ⊂ A[X]) ∧ (A′ ⊂ A[Y ]) s.s.i. A′ ⊂ A[X] ∩ A[Y ]

On en déduit que A[X, Y ][ ] = A[X][Y ][ ] = (A[X]∩A[Y ])[ ], puis le résultat énoncé par symétrie entre X et Y , et grâce à la propriété 4.

Propriété 7. Aet A[ ] ont les mêmes affectations.

Démonstration. Soit X ≡ ≪ x1 := m1,· · · , xn:= mn ≫. D’après la propriété 6, on a A[ ][X] =

A[X][ ], et d’après la propriété 4, A[X][ ] = A[X]. On en déduit A[ ][X] = A[X].

D´efinition(affectation maximale). Une affectation A′ = A[x1 := m1,· · · , xn := mn] est

maxi-male si ∀x ∈ V(R), |{m ∈ M : (A′, m) |= (P, x)}| ≤ 1. En particulier A′est maximale lorsqu’une molécule a été choisie pour chaque variable.

D´efinition(affectation valide). Une affectation A′ = A[x1 := m1,· · · , xn := mn] est valide si

∀x ∈ V(R), |{m ∈ M : (A′, m) |= (P, x)}| ≥ 1.

Propri´et´e 8. Si R ∈ R est connexe non vide, une affectation A′ _{= A[x}

1 := m1,· · · , xn := mn]

au regard de P(R) est valide si et seulement si ∃x ∈ V(R), |{m ∈ M : (A′, m) |= (P, x)}| ≥ 1, si et

seulement si A′est non vide.

D´emonstration. Supposons que R est connexe, et soit A′ = A[x1 := m1,· · · , xn := mn] une

affectation.

Si A′ est valide, alors ∀x ∈ V(R), |{m : m |= x}| ≥ 1 donc puisque R n’est pas vide, ∃x ∈ V(R), |{m : m |= x}| ≥ 1.

R´eciproquement, supposons ∃x ∈ V(R), |{m : m |= x}| ≥ 1. Supposons par l’absurde que A′ n’est pas valide, alors ∃y ∈ V(R), |{m : m |= y}| = 0. Or R est connexe, donc il existe un chemin x1,· · · , xpavec x1= x et xp = y. Il existe donc un indice i pour lequel |{m : m |= xi}| >

0 et |{m : m |= xi+1}| = 0, ainsi qu’un pr´edicat p ∈ P(R) tel que {xi, xi+1} ⊂ arg(p). Soit

mi |= xi. (f, {(xi, mi), (xj, mj) · · · }) ∈ P(R), et donc (mj |= xj). Ceci est absurde puisque

(22)

D’après ces deux définitions, une affectation est valide et maximale si ∀x ∈ V(R), |{m ∈ M : (A′_{, m) |= (P, x)}| = 1. Cette affectation définit alors de manière immédiate}

une réaction possible. Inversement, une réaction définit une affectation valide maximale. Le problème de la recherche de réactifs peut donc être redéfini comme la recherche d’une af-fectation valide maximale dans l’ensemble des axiomes induits par une règle sur un multi-ensemble.

2.4 Pr´esentation de l’algorithme

Nous avons maintenant tous les outils th´eoriques pour exposer l’algorithme de recherche de r´eactifs.

Théorème 3(maximisabilité de l’affectation de la jointure). Soient R une règle d’arité k dont les

variables sont ordonn´ees par ⋖, {x1,· · · , xc} = J⋖(R) et m1,· · · , mc ∈ M.

A[x1 := m1,· · · , xc := mc] est valide si et seulement si il existe mc+1,· · · , mk ∈ M telles que

A[x1 := m1,· · · , xn:= mk] est valide maximale.

D´emonstration. Supposons qu’il existe mc+1,· · · , mk tels que A[x1 := m1,· · · , xk := mk] est

valide, alors

A[x1 := m1,· · · , xk:= mk] = A[x1 := m1,· · · , xc := mc][xc+1:= mc+1,· · · , xk:= mk]

⊂ A[x1 := m1,· · · , xc := mc].

Comme A′ = A[x1 := m1,· · · , xk := mk] est valide, alors ∀x ∈ J⋖(R), |{m ∈ A′ : m |= x}| ≥ 1,

donc A[x1 := m1,· · · , xc := mc] est ´egalement valide.

Algorithme 5: Maximisation de A′= A[x1:= m1,· · · , xc := mc] selon ⋖

for xi= x1⋖· · · ⋖ xkdo 1 switch {p ∈ P(R) : ∃y ⋖ xi,{xi, y} ⊂ F(p)} do 2 case ∅: mi ∈ {m : m |= xi}; 3

case {p}: mi ∈ {m : m |= xi∧ ∃a |= p, a(xi) = m ∧ ∀xj⋖xi, a(xj) = mj};

4

case : mi ∈ {m : m |= xi};

5

return A′[x1 := m1,· · · , xk:= mk];

6

R´eciproquement, supposons que A′ = A[x1 := m1,· · · , xc := mc] est valide, alors

l’algo-rithme 5 retourne une affectation valide maximale. En effet, l’affectation est bien maximale, il reste donc à montrer qu’elle est valide, c’est à dire que les molécules choisis par l’algorithme existent bien et qu’elles forment un graphe pur.

´Etudions les trois cas de l’algorithme.

– Si xi n’a pas de voisine plus petite qu’elle, il existe une valeur mod´elisant xi car A′ est

valide.

– Si un unique prédicat p relie xi à des voisines plus petites, qui ont donc été déjà choisies,

il existe un axiome a |= p reliant ces voisines car A′ est valide. On choisit la mol´ecule a(xi) pour l’un de ces axiomes.

– Dans le dernier cas, xi ∈ J⋖(R), et est donc affect´ee dans A′. Comme cette affectation est

valide, {m : m |= xi} contient une et une seule valeur mi, qui est convient bien avec tous

(23)

Dans les trois cas, l’existence est assurée. De plus, la pureté du graphe est vérifiée par construc-tion.

Nous pouvons maintenant assembler tous les éléments pour construire un algorithme com-plet qui résout le problème de la recherche de réactifs. L’algorithme 6 résout ce problème pour une pour une règle R dans laquelle les variables sont triées selon ⋖ et un ensemble d’axiomes A.

Algorithme 6: Recherche d’une affectation maximale valide dans R.

forall m1|= x1,· · · , mc |= xcdo /* Chose values for J⋖(R) = (x₁,· · · , xc) */

1

if valid(A[x1 := m1,· · · , xc := mc]) then /* Check the affectation */

2

return maximize(A[x1 := m1,· · · , xc := mc]) /* there is a solution */

3

return ⊥ /* there is no solution */

4

Propri´et´e 9(Correction). L’algorithme 6 renvoie une affectation maximale valide si il en existe une et ⊥ sinon.

D´emonstration. Si l’algorithme ne retourne pas ⊥, il termine `a la ligne 3. Dans ce cas, A[x1 :=

m1,· · · , xc := mc] est valide, donc d’après le théorème 3, il existe une jointure maximale valide,

qui est celle retourn´ee par l’algorithme.

R´eciproquement, si l’algorithme retourne ⊥, montrons par l’absurde qu’il n’existe pas d’affectation maximale valide. Supposons donc qu’il existe une affectation maximale valide A[x1 := m1,· · · , xk := mk]. Les valeurs m1,· · · , mc sont test´ees par l’algorithme, mais

au-cune valeur n’a été renvoyée, puisque la ligne 4 a été atteinte. On en déduit que A[x1 :=

m1,· · · , xc := mc] n’est pas valide. Cela est absurde puisque A[x1 := m1,· · · , xk := mk] est

valide.

Propriété 10(Complexité). L’algorithme 6 s’execute en O |M(A)||J⋖(R)|+rg(R) opérations dans le

pire cas.

D´emonstration. Soit n = |M(A)| le nombre de mol´ecules dans A. Si la solution est inerte, ce

qui correspond au pire cas, il y a exactementQ

x∈J⋖(R)|{m |= x}| ≤ n

|J⋖(R)| _{ex´ecutions de la}

boucle principale. Or, chaque itération nécessite le calcul d’une affectation, dont la complexité est proportionnelle par rapport au nombre d’axiomes dans A, soit inférieur à nrg(R), puis la vérification d’une validité et le calcul d’une maximisation qui peuvent être faits en temps pro-portionnel au nombre de variables dans R, c’est à dire négligeable par rapport à la taille de A. On en déduit que la complexité est O n|J⋖(R)|+rg(R).

Remarque. Si l’ordre ⋖ définit une jointure minimale, et si on a choisi R pour que le théorème 2

soit vérifié, la complexité dans le pire cas de l’algorithme est O nC(R)+rg(R) pour n molécules dans le multi-ensemble. D’après le théorème 2, C(R) + rg(R) ≤ |V(R)|, et le gain peut même être évalué à la compilation.

L’algorithme 6 permet d’améliorer la complexité de la recherche de réactifs dans la plupart des cas. Cependant, il s’agit d’un algorithme séquentiel. Dans la partie suivant, nous allons voir comment on peut utiliser ces résultats dans le cadre d’un système décentralisé.

(24)

Chapitre 3

Algorithme d´ecentralis´e

Dans le chapitre précédent, nous avons vu qu’il était possible d’améliorer la complexité de la recherche de réactifs en étudiant les conditions de réaction des règles.

On se propose de résoudre le même problème dans le cas d’un système décentralisé de type pair-à-pair dans lequel les pairs communiquent en s’envoyant des messages délivrés de façon asynchrone. Nous faisons l’hypothèse que le réseau et les pairs sont fiables, c’est à dire que, d’une part, tout message envoyé sera délivré, et d’autre part, les pairs ne peuvent pas crasher et exécutent fidèlement les algorithmes fournis.

Dans cette partie, nous ne considèrerons que les règles de rang 2. Dans ce contexte, l’en-semble des axiomes induit est un graphe dans lequel les nœuds sont les molécules et les arêtes sont les axiomes. Les pairs participant au stockage du graphe possèdent en mémoire une liste de molécules ainsi que la liste des identifiants de leurs voisines, permettant de contacter les pairs qui les hébergent. Pour augmenter la localité, des migrations de molécules sur les pairs voisins sont organisés.

Le but de ce chapitre est de montrer que la recherche de réactifs et la détection de l’iner-tie peuvent être résolus dans ce contexte en utilisant l’algorithme introduit dans le chapitre précédent. Le principe de cet algorithme est de rechercher des affectations valides dans l’en-semble des axiomes induits. Il est donc nécessaire de commencer par construire cet enl’en-semble. Trois sous-problèmes doivent être résolus pour obtenir un algorithme complet.

1. La construction du graphe des axiomes induits, présentée dans la première section, re-quiert l’évaluation de tous les prédicats nécessaires.

2. L’algorithme 6, présenté dans le chapitre précédent, doit ensuite être exécuté sur le graphe ainsi construit. La deuxième section expliquera comment on peut faire les choix et les affectations de façon décentralisée.

3. Il est enfin nécessaire de regrouper toutes les informations nécessaires à la détection de l’inertie de la sous-solution. Cela sera abordé dans la dernière section.

3.1 Construction de l’ensemble d’axiomes induits

Le temps d’exécution de l’évaluation des propositions est imprédictible. Pour cette rai-son, nous prendrons le nombre d’évaluations comme une mesure de la complexité. Dans ce contexte, il convient d’effectuer tous les tests nécessaires une et une seule fois.

(25)

Principe général de la construction du graphe. Imaginons tout d’abord que l’on veuille tes-ter deux-à-deux toutes les molécules entre elles. Une façon de s’en sortir serait d’utiliser un sac de molécules entre lesquelles tous les tests ont déjà été effectués. Ce sac est initialement vide, et lors de l’ajout d’une molécule m1, celle ci est confrontée à toutes les molécules du sac tout

en y étant insérée.

Que se passe-t-il si une deuxième molécule m2 est insérée avant que m1 ait terminé son

travail ? Dans ce cas, le nombre de tests entre m1 et m2 d´epend de l’ordre de parcours du

sac. Si la molécule est insérée avant d’effectuer les tests, celui entre m1 et m2 risque d’être

exécuté deux fois. Or, cette situation o ù de nombreuses molécules doivent être insérées en même temps correspond bien à la phase d’initialisation, puis de l’insertion des produits d’une réaction produisant plusieurs nouvelles molécules. Plus grave encore, si les molécules sont insérées après les tests, ce dernier risque de ne pas être du tout effectué, ce qui rendrait des réactions introuvables et rendrait faux l’ensemble du dispositif.

L’enseignement que nous pouvons tirer de cette réflexion est qu’une synchronisation est nécessaire lors de l’insertion d’une molécule. On peut résoudre ce problème grâce à une liste de molécules. Une molécule est insérée en début de liste et est testée avec toutes les molécules placées derrière elle dans la liste. Ainsi, deux molécules seront toujours ajoutées l’une après l’autre à l’extrémité de la chaˆıne, et le test entre les deux sera bien effectué une unique fois.

Ici, nous ne voulons pas tester tous les couples de molécules, mais seulement les molécules pouvant être passées en arguments d’un même prédicat. Aussi, on considère l’utilisation d’une liste différente pour chaque variable. La synchronisation doit alors être faite entre les extrémités de toutes les listes.

Une structure en arbres pour la construction du graphe. C’est ce principe que nous pro-posons d’adapter pour la construction répartie du graphe des molécules. Les ensembles de molécules de chaque variable sont réparties sur plusieurs pairs. L’un de ceux-ci joue le r ôle de l’extrémité de la liste dans le modèle précédent. Il doit donc être facilement accessible.

Nous proposons d’organiser les pairs en arbres, un par variable, dont les racines sont les points d’insertion. Pour faciliter le raisonnement, nous consid`ererons que les arbres sont bi-naires, bien que le nombre de fils ne soit pas vraiment important.

Plus précisément, chaque nœud de l’arbre héberge trois ensembles de molécules. Lors-qu’une nouvelle molécule est ajoutée dans la solution, elle est placée dans l’ensemble U, pour

unregistered, qui regroupe les molécules qui n’ont pas encore été insérées dans l’ensemble R,

pour registered, des molécules enregistrées. Le troisième ensemble, appelé T, pour to test, re-groupe les molécules enregistrées pour lesquelles il reste des tests à effectuer.

Chemin suivi par une molécule. Lorsqu’une nouvelle molécule est ajoutée dans la solution, elle est placée dans l’ensemble U de n’importe quel nœud de n’importe quel arbre. Au fil du temps, elle monte dans l’arbre jusqu’à atteindre la racine. Alors, elle est transférée à la racine de l’arbre gérant la variable à laquelle elle est rattachée pour y être enregistrée dans l’ensemble R, ainsi qu’à l’ensemble T de toutes les racines correspondant à des variables pour lesquelles le test est nécessaire. La molécule dans R descend ensuite dans l’arbre pour laisser la place aux nouvelles inscriptions, tandis que les copies de la molécule dans T sont diffusées à tous les nœuds de l’arbre pour faire les tests. Il est nécessaire d’empêcher les molécules de R de doubler celles de T pour garantir l’existence et l’unicité des tests.

(26)

FIGURE3.1 – L’organisation des pairs qui participent à la construction du graphe : chaque pair possède un ensemble de molécules à enregistrer, un ensemble de molécules déjà enregistrer et un ensemble de molécules à tester à transmettre aux fils. Les racines ont un r ôle particulier puisqu’elles doivent initier les tests entre molécules.

L’algorithme 7 présente cette migration du point de vue d’un nœud de l’arbre. À l’instar des protocoles de gossip, chaque pair exécute le même algorithme périodiquement. Les racines des arbres et les autres nœuds exécutent des protocoles différents, dont nous allons à présent expliquer les grandes lignes.

Le but des racines est d’enregistrer le plus possible de molécules pour débuter les réactions. Nous venons de voir qu’il était nécessaire d’ajouter une phase de synchronisation entre les racines. Celle-ci est gérée par un jeton qui tourne entre les racines selon un ordre prédéfini. Périodiquement, donc, la racine qui possède le jeton enregistre les molécules de U dont le type est le même que celui de l’arbre dont elle est la racine et contacte les autres racines pour leur transmettre :

– l’ensemble des mol´ecules qu’elles doivent elles-mˆeme enregistrer pour faire corres-pondre les types,

– l’ensemble des molécules qu’elle a enregistré au début de la période pour lesquelles des tests doivent être effectués

– et le jeton `a la racine de l’arbre du type suivant.

De leur c ôté, les autres nœuds doivent permettre aux molécules pas enregistrées de re-joindre la racine, et aux autres de descendre dans l’arbre. Cela est effectué grâcé à trois mes-sages. Premièrement, un fils contacte son père dans l’arbre, en lui envoyant des informations à propos de sa charge personnelle et d’autres utiles à la détection de l’inertie (voir section 3.3).

`

A la réception de ce message, le père calcule le nombre de molécules à échanger. Le choix de ce nombre peut permettre la mise en œuvre d’une politique, visant par exemple à maximi-ser la taille des messages o ù à équilibrer la charge entre les nœuds de l’arbre. Les molécules de T doivent être envoyées en priorité sur celles de R pour assurer l’unicité des tests. Dans

(27)

l’algorithme 7 à la ligne 29, on utilise la fonction T.get once f or each son(n, son) qui retourne min(n, |T |) molécules de T, tout en assurant que chaque molécule soit retournée une et une seule fois pour chaque fils. Lorsqu’une molécule a été retournée pour tous les fils, elle est supprimée de l’ensemble. À la ligne 30, la fonction R.get and remove(n, son) retourne un en-semble de même taille, mais supprime les molécules qui ont été retournées, indépendament du fils qui a effectué la requête. Ainsi, la réponse du père à son fils comprend un ensemble de molécules à tester, un ensemble de molécules enregistrées et le nombre de molécules à envoyer en retour.

`

A son tour, le fils reçoit le message et fait les tests entre les nouvelles molécules à tester et les molécules enregistrées dont il avait déjà la charge. Les tests entre les molécules envoyées par le père ont déjà été effectués, et ils ne doivent donc pas être refaits. En retour, le fils envoie le nombre de molécules pas enregistrées demandé.

Lorsqu’un nouvel axiome est découvert, la version enregistrée des deux molécules doit être notifiée. Il est donc nécessaire de rechercher la molécule dans l’arbre. Comme nous allons le voir à présent, la structure d’arbres que nous venons de définir est particulièrement bien adaptée à cette recherche.

Recherche d’une molécule dans l’arbre. La molécule est toujours enregistrée à la racine, mais elle migre ensuite dans l’arbre. Il ne suffit donc pas d’une adresse pour la retrouver. Nous proposons donc de nous servir de la structure précédement décrite comme d’une table de hashage distribuée. Au moment de leur création, les molécules reçoivent un identifiant unique formé de l’identifiant de leur créateur et d’un numéro unique au créateur qui servent à identifier la molécule, ainsi qu’un nombre réel tiré aléatoirement selon une loi uniforme entre 0 et 1 qui permet de la retrouver dans l’arbre.

`

A chaque nœud d’un arbre est associ´e un intervalle de [0, 1] tel que : – l’intervalle de la racine est [0, 1],

– les intervalles de deux fils d’un mˆeme nœud sont disjoints,

– la réunion des intervalles des fils d’un nœud est égale à l’intervalle du nœud.

Une valeur typique pour ces intervalles dans un arbre binaire est [0, 1] pour la racine, [0; 0, 5] et ]0, 5; 1] pour ses fils, les quatre intervalles de longueur 1₄ pour ses petits fils, et ainsi de suite. Nous voulons faire en sorte que toutes les molécules de R présentes sur un nœud aient la partie aléatoire de leur identifiant comprise dans l’intervalle du nœud. En conséquence, cela est également vrai pour toutes les molécules du sous arbre dont le nœud est la racine. Pour obtenir ce résultat, il suffit de n’envoyer à chaque fils que les molécules dont la partie aléatoire correspond.

Pour trouver une molécule dans l’arbre, il suffit donc d’envoyer un message à la racine, qui la recherche parmi les molécules qu’elle héberge, et transmet le message au fils dont l’in-tervalle correspond si elle ne la trouve pas. Celui-ci répète l’opération, et ainsi de suite jusqu’à ce que la molécule soit trouvée. La complexité dans le pire cas est donc égale à la hauteur de l’arbre en terme de messages échangés. Une amélioration consiste à répondre en communi-quant l’adresse trouvée au pair qui a initié la requête. Ainsi, lors de la demande suivante, le haut de l’arbre n’aura pas besoin d’être exploré. Si h est la hauteur de l’arbre, la complexité pour n requêtes par le même pair est donc réduite à 1 + h_n −→

n→∞1 message.

Cependant, l’algorithme tel qu’il vient d’être introduit n’est pas suffisant. En effet, il est possible que la recherche d’une molécule soit effectuée en parallèle de la migration de cette

(28)

Algorithme 7: Algorithme simplifi´e de la construction du graphe peer: father; 1 peer[ ]: sons; 2 sethmoleculei: R, U, T; 3

boolean: is root, has token;

4

maphtype, peeri: roots;

5 type: type; 6 periodically: 7 ifis root then 8

ifhas token then 9

foralltypet do 10

sethmoleculei: good type = {m ∈ U : m |= t};

11

sethmoleculei: need test = {m ∈ U : m |= type ∧ type ↔ t};

12

sendcontact roots(good type, need test, t = type+1) to roots(t);

13 R← R ∪ {m ∈ U : m |= type}; 14 U ← ∅; 15 else 16

sendcontact father(R.size(), U.size(), T.size()) to father;

17

end

18

receivingcontact roots(sethmoleculei good t, sethmoleculei test, boolean token) :

19

has token← token;

20

U ← U ∪ good t;

21

T ← T ∪ test;

22

forallMolecule m ∈ test do

23 forallMolecule mr ∈ R do 24 DoTest(m, mr); 25 end 26

receivingcontact father(int sizeU, int sizeR, int sizeT) from son :

27

int×int: (send, send back) = f (sizeU, sizeR, sizeT, U.size, R.size, T.size);

28

sethmoleculei: sendT = T.get once f or each son(send, son);

29

sethmoleculei: sendR = R.get and remove(send − sendT.size, son);

30

sendanswer son(sendT, sendR, send back) to son;

31

end

32

receivinganswer son(sethmoleculei sendT, sethmoleculei sendR, int send back) :

33

T ← T ∪ sendT ;

34

forallMolecule m ∈ sendT do

35 forallMolecule mr ∈ R do 36 DoTest(m, mr); 37 R← R ∪ sendR; 38

sendack father(U.get and remove(sendBack)) to father;

39

end

40

receivingack father(sethmoleculei sendU) :

41

U ← U ∪ sendT ;

42

end