1061 lines
58 KiB
TeX
1061 lines
58 KiB
TeX
\begin{refsection}[
|
||
bib/hdr_noverlan.bib,
|
||
bib/hdr_verlan.bib,
|
||
bib/insdel.bib,
|
||
bib/pn.bib,
|
||
bib/psystems.bib,
|
||
bib/mcrs.bib,
|
||
bib/arrays.bib,
|
||
bib/programming.bib,
|
||
bib/algebra.bib,
|
||
bib/complex-sys.bib,
|
||
bib/sivanov.bib,
|
||
bib/sivanov-extra.bib
|
||
]
|
||
|
||
\section{Activités de recherche}
|
||
J'ai commencé mes travaux de recherche en 2009 au sein de l'Institut
|
||
de Mathématiques et d'Informatique de Moldavie sous la direction de
|
||
Yurii \textsc{Rogozhin} et j'ai continué en 2012 par entreprendre une
|
||
thèse sous la direction de Serghei \textsc{Verlan} au Laboratoire
|
||
d'Algorithmique, Complexité et Logique de l'Université Paris Est
|
||
Créteil. À présent je suis ATER à l'École Supérieure d'Informatique
|
||
Appliquée à la Gestion (ÉSIAG).
|
||
J'ai également eu de nombreuses collaborations
|
||
internationales, notamment avec Rudolf \textsc{Freund} et Ion
|
||
\textsc{Petre}. J'ai aussi travaillé activement avec Elisabeth
|
||
\textsc{Pelz}, Artiom \textsc{Alhazov}, Vladimir
|
||
\textsc{Rogojin}. Afin de collaborer avec Ion \textsc{Petre}, j'ai
|
||
effectué de multiples visites au laboratoire Combio à l'université Åbo
|
||
Akademi à Turku, Finlande.
|
||
|
||
Les sujets de recherche que j'ai abordés jusqu'à maintenant se situent
|
||
dans les domaines du calcul inspiré par la biologie et des langages
|
||
formels. Lors de mon doctorat, j'ai travaillé également sur des
|
||
problèmes non reliés directement au sujet de ma thèse. Dans la suite
|
||
de cette section, je résume ma thèse, puis les résultats obtenus en
|
||
dehors de son cadre.
|
||
|
||
\subsection{Travaux de thèse}
|
||
Ma thèse porte sur la puissance d'expression et l'universalité de
|
||
modèles de calcul inspirés par la biologie. Les travaux présentés se
|
||
structurent en quatre parties. Dans la première il s'agit de la
|
||
puissance d'expression des systèmes d'insertion/effacement ({\em
|
||
insertion-deletion systems}), un modèle de réécriture de chaînes de
|
||
symboles formels par les opérations d'insertion et d'effacement. La
|
||
deuxième partie du manuscrit se focalise sur l'universalité des
|
||
réseaux de processeurs évolutionnaires ({\em networks of evolutionary
|
||
processors}), qui est une formalisation d'un ensemble des unités de
|
||
traitement de chaînes de caractères reliés en réseau. La troisième
|
||
partie considère les machines à registres universelles à deux et à
|
||
trois registres, ainsi qu'une généralisation de ce modèle. La dernière
|
||
partie porte sur l'universalité des réseaux de Petri avec des arcs
|
||
inhibiteurs.
|
||
|
||
Nous rappelons que l'universalité est la propriété d'une classe de
|
||
modèles de calcul d'avoir un objet, dit universel, qui peut répliquer
|
||
les résultats de n'importe quel autre objet de cette classe, la
|
||
simulation pouvant éventuellement se faire à un codage près. D'autre
|
||
part, la complétude computationnelle est la propriété d'une classe de
|
||
contenir, pour tout langage récursivement énumérable, un objet qui
|
||
l'engendre.
|
||
|
||
\subsubsection{Systèmes d'insertion/effacement}
|
||
Les opérations d'insertion et d'effacement sont connues depuis
|
||
longtemps dans la théorie des langages formels, surtout la variante
|
||
sans contexte qui généralise les opérations de concaténation et
|
||
quotient, deux opérations
|
||
fondamentales~\cite{Haussler82,KariPhD}. L'inspiration qui a motivé
|
||
l'introduction de l'insertion et l'effacement vient de la
|
||
linguistique, car elles semblent modéliser assez précisément les
|
||
procédés de construction des phrases dans une langue
|
||
vivante~\cite{Marcus69,PaunKluwer97}. Il a été montré récemment que
|
||
l'étude de l'insertion de l'effacement est intéressante du point de
|
||
vue biologique, car ses opérations formalisent l'hybridation erronée
|
||
des brins d'ADN ({\em mismatched DNA annealing})~\cite{PRSbook}. De
|
||
plus, il a été découvert que même l'édition de l'ARN ({\em RNA
|
||
editing}) réalisée par certains protozoaires consiste généralement
|
||
en des ajouts et des suppressions dans des brins d'ARN.
|
||
|
||
De manière intuitive, une règle d'insertion rajoute une sous-chaîne à
|
||
une chaîne de caractères dans un contexte donné. Une règle
|
||
d'effacement agit de la façon duale : elle supprime une sous-chaîne
|
||
d'une chaîne de caractères, dans un contexte donné. Un système
|
||
d'insertion/effacement ({\em insertion-deletion system}) possède
|
||
un ensemble fini de règles d'insertion
|
||
et d'effacement ; il engendre un langage en appliquant ces règles
|
||
séquentiellement à un ensemble fini de mots dits axiomes. La
|
||
complexité d'un système d'insertion/effacement est décrite par le
|
||
6-uplet $(n,m,m'; p,q,q')$ dit taille, où les premiers trois composants
|
||
représentent la longueur maximale de la sous-chaîne insérée et la
|
||
taille maximale des contextes à gauche et à droite, alors que les
|
||
trois derniers composants décrivent les mêmes paramètres pour les
|
||
règles d'effacement.
|
||
|
||
Dans le cadre de ma thèse nous nous sommes intéressés tout d'abord à
|
||
des systèmes d'insertion/ef\-face\-ment de taille $(1,m,0; 1,q,0)$,
|
||
c'est-à-dire aux systèmes dans lesquels toutes les règles n'ont pas de
|
||
contexte à droite et insèrent ou suppriment un caractère. Nous avons
|
||
montré que ces systèmes engendrent tous les langages rationnels et
|
||
même certains langages algébriques. D'un autre côté, nous avons prouvé
|
||
que pour tout système de taille $(1,m,0;1,q,0)$ avec $m\geq 2$ ou
|
||
$q\geq 2$ il existe un système de taille $(1,2,0; 1,1,0)$ et un autre
|
||
de taille $(1,1,0; 1,2,0)$ qui le simule. Nous nous sommes
|
||
intéressés aussi aux systèmes de taille $(1,1,0;1,1,0)$ qui, malgré
|
||
leur simplicité apparente, peuvent engendrer des langages
|
||
non algébriques. Afin de mieux analyser le comportement dynamique de
|
||
ces systèmes, nous avons introduit un outil de représentation
|
||
graphique de leurs dérivations.
|
||
|
||
Nous avons ensuite considéré les systèmes d'insertion/effacement avec
|
||
trois mécanismes de contrôle : contrôle par graphe ({\em graph
|
||
control}), contrôle semi-conditionnel ({\em semi-conditional
|
||
control}) et contextes aléatoires ({\em random context
|
||
control}). Nous avons prouvé que les systèmes équipés de ces
|
||
mécanismes sont Turing complets avec de très petites
|
||
règles. Notamment, nous avons prouvé que le contrôle semi-conditionnel
|
||
augmente la puissance d'expression des systèmes
|
||
d'insertion/effacement de taille $(1,0,0;1,0,0)$, c'est-à-dire des
|
||
systèmes avec des règles sans contexte, et les rend Turing complets.
|
||
|
||
Les résultats concernant les systèmes d'insertion/effacement avec des
|
||
mécanismes de contrôle ont été publiés
|
||
dans~\cite{DBLP:conf/membrane/IvanovV13,DBLP:journals/fuin/0001V15}.
|
||
|
||
Nous avons continué l'étude de la puissance d'expresison des systèmes
|
||
d'insertion/effacement de tailles $(1,2,0;1,1,0)$ et $(1,1,0;1,2,0)$
|
||
avec contrôle par graphe et nous avons montré que deux états dans le
|
||
graphe de contrôle suffisaient pour rendre ces systèmes Turing
|
||
complets~\cite{DBLP:conf/mcu/0001V15}. Cela améliore la construction
|
||
utilisant trois états présentée dans ma thèse. Afin de faire cette
|
||
construction améliorée nous avons introduit les règles d'insertion et
|
||
d'effacement étendues ; dans ces règles les contextes ne sont plus des
|
||
chaînes de caractères prédéfinies, mais peuvent être des langages
|
||
rationnels.
|
||
|
||
\subsubsection{Réseaux de processeurs évolutionnaires}
|
||
Les réseaux de processeurs évolutionnaires ({\em networks of
|
||
evolutionary processors}) sont un modèle de calcul
|
||
inspiré par l'activité des organites d'une cellule biologique ou par
|
||
la collaboration des cellules d'un tissu~\cite{CMVMS2001,CVS97}. Un
|
||
processeur évolutionnaire peut effectuer en parallèle des opérations
|
||
élémentaires (insertion, effacement, substitution d'un symbole) sur
|
||
toutes les chaînes de caractères qu'il contient. Les processeurs sont
|
||
connectés en réseau et échangent les chaînes de caractères qu'ils
|
||
produisent. Ils disposent de filtres à l'entrée et à la sortie, ce qui
|
||
leur permet de ne pas prendre en compte certaines chaînes.
|
||
|
||
La complétude computationnelle des réseaux de processeurs
|
||
évolutionnaires a été montrée dès leur
|
||
introduction~\cite{CMVMS2001,CVS97}. Des variations au modèle ont été
|
||
proposées plus tard et prouvées Turing complètes elles
|
||
aussi~\cite{AMVR2006,CMVMS2003}. Nous nous sommes intéressés plutôt à
|
||
l'universalité et à la minimisation du nombre de règles
|
||
dans les réseaux universels. Nous
|
||
avons ainsi construit des réseaux universels à 4, 5 et 7 règles
|
||
seulement, avec des fonctions de codage différentes.
|
||
Ces résultats on été publiés dans~\cite{DBLP:journals/jalc/0001RV14}.
|
||
|
||
\subsubsection{Machines à registres}
|
||
Les machines à registres sont un modèle de calcul classique, dérivé
|
||
directement de la machine de Turing~\cite{Minsky1961,Wang:1957}. Une
|
||
telle machine possède un nombre fini de registres, qui peuvent
|
||
contenir des entiers non négatifs. Le programme d'une machine à
|
||
registres est une liste étiquetée d'instructions élémentaires :
|
||
l'incrément d'un registre, le décrément d'un registre et le teste si
|
||
un registre est vide. Les machines à registres sont ainsi
|
||
très proches de l'organisation des ordinateurs digitaux habituels.
|
||
|
||
Il a été montré que les machines à registres sont Turing complets et
|
||
qu'en plus n'importe quelle fonction calculable sur les entiers non
|
||
négatifs peut être calculée par une machine à deux registres si les
|
||
entrées de la fonction sont déjà encodées, ou à trois registres si la
|
||
machine doit faire l'encodage par elle-même~\cite{minsky67}. Cela
|
||
implique l'existence de machines à deux registres et à trois registres
|
||
universelles. Néanmoins, aucun programme d'une telle machine n'a été
|
||
présenté dans la littérature, or une telle construction concrète
|
||
permet d'estimer la taille de structures universelles dérivées et de
|
||
les optimiser ensuite. Dans ma thèse nous avons donc appliqué la
|
||
procédure décrite dans~\cite{minsky67} pour construire des machines à
|
||
deux et à trois registres universelles en simulant les machines
|
||
universelles présentées en~\cite{Korec}.
|
||
|
||
Nous nous sommes aussi intéressés à la façon dont les machines à
|
||
registres sont simulées par d'autres modèles de calcul tels que
|
||
systèmes de réécriture de multiensembles, réseaux de Petri, ou réseaux
|
||
de processeurs évolutionnaires. Nous avons remarqué que tous ces
|
||
modèles peuvent simuler plusieurs instructions d'une machine à
|
||
registres en un seul pas. Autrement dit, ces instructions sont souvent
|
||
trop élémentaires. Dans le but de définir un modèle proche aux
|
||
machines à registres, mais qui utiliserait des instructions plus
|
||
expressives, nous avons proposé les machines à registres généralisées
|
||
({\em generalised register machines}). Une telle machine peut
|
||
effectuer plusieurs incréments, décréments, ou tests si un registre
|
||
est à zéro en une seule transition.
|
||
|
||
Les machines à registres habituelles peuvent être vues comme des
|
||
machines à registres généralisées qui n'exécutent qu'une seule
|
||
opération par transition. Dans une telle machine il est possible de
|
||
réduire le nombre d'états en utilisant des transitions plus
|
||
complexes. Dans ma thèse nous avons appliqué cette réduction pour
|
||
construire des machines à registres universelles à 7 états seulement,
|
||
cela en simulant les constructions présentées dans~\cite{Korec}.
|
||
|
||
\subsubsection{Systèmes de réécriture de multiensembles et réseaux de Petri}
|
||
La dernière partie de ma thèse porte sur l'universalité des systèmes
|
||
de réécriture de multiensembles avec des inhibiteurs et aussi des
|
||
réseaux de Petri avec des arcs inhibiteurs --- deux modèles qui sont
|
||
fondamentalement similaires. En effet, un état (marquage) d'un réseau
|
||
de Petri est décrit par une fonction qui associe à chaque place le
|
||
nombre de jetons qu'elle contient ; or le marquage est un
|
||
multiensemble sur l'alphabet des symboles qui désignent les
|
||
places. Les transitions de réseaux de Petri correspondent ainsi aux
|
||
règles de réécriture de multiensembles.
|
||
|
||
Il a été montré que savoir si un marquage peut être atteint par un
|
||
réseau de Petri donné est décidable~\cite{Mayr:1981}. La même
|
||
affirmation est donc valable dans le cas des systèmes de réécriture de
|
||
multiensembles simples. Plusieurs variations ont été proposées afin
|
||
d'étendre la puissance d'expression de ces modèles, dont l'idée des
|
||
inhibiteurs. Dans les réseaux de Petri, un arc inhibiteur entre une
|
||
place et une transition empêche celle-ci de se déclencher si la place
|
||
n'est pas vide. De la même manière, on peut munir une règle de
|
||
réécriture de multiensembles d'une collection de symboles qui ne
|
||
doivent pas être présents pour que la règle soit applicable. Il a été
|
||
prouvé que les réseaux de Petri avec des arcs inhibiteurs et les
|
||
systèmes de réécriture de multiensembles avec des inhibiteurs sont
|
||
Turing complets~\cite{BMVPR2002,Reinhardt08}, car ils peuvent simuler
|
||
assez directement les machines à registres.
|
||
|
||
Dans ma thèse nous avons construit plusieurs réseaux de Petri avec des
|
||
arcs inhibiteurs universels. Nous avons défini la taille d'un réseau
|
||
comme étant le 4-uplet $(p,t,i,d)$ où $p$ est le nombre de places, $t$
|
||
est le nombre de transitions, $i$ est le nombre d'arcs inhibiteur et
|
||
$d$ et le nombre maximal d'arcs incidents à une transitions (le degré
|
||
maximal). Nous nous sommes proposé de construire des réseaux de Petri
|
||
universels tout en minimisant chacun de ces paramètres. Nous avons
|
||
notamment décrit des réseaux universels avec quatre et cinq places
|
||
uniquement et d'autres avec deux et trois arcs inhibiteurs (les
|
||
chiffres varient selon l'encodage des entrées et des sorties). Il est
|
||
remarquable que deux est le nombre minimal d'arcs inhibiteurs
|
||
nécessaires pour atteindre la complétude computationnelle : les
|
||
réseaux de Petri avec un seul arc inhibiteur ne sont pas Turing
|
||
complets~\cite{Reinhardt08}.
|
||
|
||
Même si les résultats portant sur l'universalité présentés dans la dernière partie
|
||
de ma thèse apparaissent sous la forme de réseaux de Petri, la
|
||
correspondance directe avec les systèmes de réécriture de
|
||
multiensembles permet de formuler immédiatement les mêmes résultats
|
||
pour ceux-ci.
|
||
|
||
Les résultats de ma thèse portant sur les réseaux de Petri universels
|
||
ont été publiés
|
||
dans~\cite{DBLP:conf/dcfs/0001PV14,DBLP:journals/corr/IvanovPV13,DBLP:journals/jalc/Alhazov0PV16}.
|
||
|
||
\subsection{Travaux hors thèse}
|
||
Avant le début de ma thèse et pendant mon doctorat j'ai travaillé sur
|
||
des problèmes qui n'étaient pas directement reliés à ceux qui sont
|
||
exposés dans le manuscrit. Ces travaux se situent également dans le
|
||
cadre du calcul naturel et de la théorie des langages formels. Je me
|
||
suis premièrement concentré sur les systèmes à membranes ({\em
|
||
membrane systems}) qui sont un modèle inspiré par la structure et
|
||
fonctionnement de la cellule biologique. J'ai aussi travaillé sur les
|
||
systèmes à réactions ({\em reaction systems}) qui représentent une
|
||
abstraction formelle d'un réacteur biochimique. Finalement, j'ai
|
||
participé à des travaux dans le domaine des grammaires de tableaux
|
||
({\em array grammars}), un modèle qui étend les grammaires classiques
|
||
à la réécriture des parties des tableaux.
|
||
|
||
\subsubsection{Systèmes à membranes}
|
||
Le modèle des systèmes à membranes a été introduit par Gheorghe Păun
|
||
qui s'est inspiré de la nature et du fonctionnement de la cellule
|
||
vivante~\cite{Paun98computingwith,paun2002membrane,Paun:2010:OHM:1738939}. Un
|
||
système à membranes est un ensemble de compartiments imbriqués les uns
|
||
dans les autres et délimités par des membranes ; une membrane contient
|
||
un multiensemble d'objets dont chacun représente une molécule
|
||
biochimique. Les interactions entre les molécules sont modélisées par
|
||
l'action des règles de réécriture de multiensembles. Les
|
||
systèmes à membranes sont essentiellement des systèmes de réécriture
|
||
parallèle de multiensembles~\cite{FLGPVZ2014} ; ils représentent la
|
||
cellule vivante de façon naturelle, constituant ainsi un outil clair et
|
||
puissant pour la modélisation des processus biologiques et plus
|
||
généralement de systèmes dynamiques complexes.
|
||
|
||
Les thématiques que j'ai abordées dans ma recherche sur des systèmes à
|
||
membranes se divisent principalement en trois groupes :
|
||
\begin{itemize}
|
||
\item la création des outils performants et flexibles de simulation
|
||
des systèmes à membranes,
|
||
\item développement des algorithmes distribués qui peuvent être
|
||
ensuite implémentés dans des systèmes biologiques,
|
||
\item étude de la puissance de calcul de différentes variantes
|
||
étendues du modèle de base.
|
||
\end{itemize}
|
||
|
||
La création d'un simulateur de systèmes à membranes a toujours été une
|
||
question très pertinente qui a attiré beaucoup d'efforts de la part
|
||
des chercheurs dans le domaine. Un tel simulateur est un outil
|
||
essentiel qui permet de tester si une construction concrète réalise le
|
||
comportement désiré. J'ai participé à ce travail en développant un
|
||
simulateur avec des moteurs des simulations échangeables pouvant être
|
||
réalisés en des langages différents. J'ai notamment fourni un moteur
|
||
de simulation utilisant la technologie OpenCL de programmation
|
||
pour des architectures parallèles et un autre, plus flexible mais
|
||
moins performant, implémenté en Haskell.
|
||
|
||
En ce qui concerne le développement des algorithmes distribués, je me
|
||
suis tout d'abord focalisé sur les modèles de systèmes à membranes
|
||
sans horloge ({\em clock-free membrane systems}), dans lesquels une
|
||
application de règle peut durer un temps réel arbitraire. L'absence
|
||
de l'horloge globale rapproche le modèle des systèmes parallèles
|
||
composés d'un certain nombre de processus qui interagissent. Dans mon
|
||
travail, j'ai exprimé les mécanismes de synchronisation en termes de
|
||
règles de réécriture de multiensembles et j'ai montré comment ces
|
||
mécanismes pouvaient être utilisés pour la résolution de quelques problèmes de
|
||
concurrence classiques.
|
||
Les résultats concernant les systèmes à membranes sans horloge ont été
|
||
publiés
|
||
dans~\cite{DBLP:journals/ijcm/Ivanov13,DBLP:conf/membrane/Ivanov11}.
|
||
|
||
Nous avons continué l'exploration des algorithmes distribués en
|
||
implémentant les chaînages avant et arrière ({\em forward and backward
|
||
chaining}) dans les systèmes à membranes actives, c'est-à-dire les
|
||
systèmes dans lesquels les membranes peuvent se diviser. Le chaînage
|
||
avant est une méthode de déduction qui applique des implications
|
||
logiques en partant des prémisses pour en déduire de nouvelles
|
||
conclusions. Le chaînage avant consiste donc à construire toutes les
|
||
conclusions déductibles à partir des axiomes jusqu'à ce que la
|
||
proposition cible soit obtenue. Par opposition, le chaînage arrière
|
||
part des conclusions pour essayer de remonter aux axiomes. Le chaînage
|
||
arrière a souvent tendance à explorer moins de possibilités et est
|
||
préféré dans les cas d'utilisation pratiques. Il est remarquable que
|
||
les implications logiques se prêtent à une représentation naturelle en
|
||
termes de règles de réécriture de multiensembles ; or c'est de cette
|
||
similarité que nos constructions profitent. De plus, nos
|
||
implémentations bénéficient du parallélisme intrinsèque aux systèmes à
|
||
membranes.
|
||
Ce résultat a été publié dans~\cite{DBLP:journals/ijncr/IvanovARG11}.
|
||
|
||
Concernant les variations du modèle de base, nous avons proposé une
|
||
extension assez naturelle qui permet aux systèmes à membranes de se
|
||
modifier eux-mêmes. Dans le cadre de ce genre de système, les règles
|
||
de réécriture sont données par le contenu de certaines paires de
|
||
membranes. Il est ainsi possible de modifier les règles au cours de
|
||
l'évolution du système en rajoutant ou en supprimant des objets dans les
|
||
membranes qui définissent ces règles. Nous avons donné à ces systèmes
|
||
l'appellation de systèmes polymorphes ({\em polymorphic membrane
|
||
systems}) et nous avons montré que le polymorphisme permettait de
|
||
calculer des fonctions exponentielles avec des règles relativement
|
||
simples. Je me suis ensuite intéressé à la puissance de calcul de
|
||
systèmes polymorphes dans leur version la plus élémentaire et j'ai
|
||
démontré quelques résultats concernant les bornes inférieures et
|
||
supérieures de la famille des langages qu'ils peuvent engendrer. J'ai
|
||
prouvé également l'existence d'une hiérarchie infinie dans cette
|
||
famille des langages.
|
||
|
||
Les résultats concernant les systèmes à membranes polymorphes ont été
|
||
publiés
|
||
dans~\cite{DBLP:conf/membrane/AlhazovIR10,DBLP:conf/membrane/Ivanov14}.
|
||
|
||
\subsubsection{Systèmes à réactions}
|
||
Les systèmes à réactions ({\em reaction systems}) sont un autre modèle
|
||
formel inspiré par la cellule biologique, et surtout par les réactions
|
||
chimiques qui y ont
|
||
lieu~\cite{brij-atofrs,ehrenfeucht2007reaction}. Les systèmes à
|
||
réactions se fondent sur deux principes. Le premier est le principe de
|
||
non permanence : une ressource qui ne participe pas à une interaction
|
||
disparaît du système. Le deuxième principe est que si une ressource
|
||
est présente dans le système, alors elle y est en quantité
|
||
illimitée. Cela fait des systèmes à réactions un modèle intrinsèquement
|
||
qualitatif qui manipule des ensembles de symboles.
|
||
|
||
Les interactions entre les symboles dans les systèmes à réactions sont
|
||
régies par les réactions. Une réaction contient trois ensembles: les
|
||
réactifs, les inhibiteurs et les produits. Pour qu'une réaction soit
|
||
applicable à un ensemble, celui-ci doit contenir tous les réactifs de
|
||
la réaction et ne contenir aucun de ses inhibiteurs. Le résultat de
|
||
cette application est l'ensemble des produits ; les symboles qui n'ont
|
||
pas été consommés par la réaction disparaissent. Le résultat
|
||
d'application concomitante de plusieurs réactions est l'union de leurs
|
||
produits.
|
||
|
||
Les systèmes à réactions étant un modèle de calcul assez particulier,
|
||
beaucoup de chercheurs se sont intéressés à leurs propriétés
|
||
formelles. Dans notre travail nous sommes revenus à la motivation
|
||
d'origine et nous nous sommes proposé d'utiliser les systèmes à
|
||
réactions pour modéliser les voies métaboliques d'une cellule. Une
|
||
partie essentielle d'une telle modélisation serait la vérification
|
||
formelle qu'un système concret correspond suffisamment bien au
|
||
phénomène qu'il modélise. Dans ce but, nous avons adapté plusieurs concepts
|
||
utilisés dans la modélisation biologique habituelle, dont la
|
||
conservation de la masse, et nous avons prouvé que décider la plupart
|
||
des propriétés qu'un système à réactions peut avoir vis-à-vis de ces
|
||
concepts est un problème $\NP$-, $\coNP$-, ou même
|
||
$\PSPACE$-complet. Nous nous sommes ensuite focalisés sur la
|
||
conservation de la masse et nous avons montré que cette notion donne
|
||
naissance à une structure formelle qui facilite la réponse à certaines
|
||
questions concernant les propriétés de conservation d'un système à
|
||
réactions.
|
||
|
||
Ces résultats concernant les systèmes à réactions ont été publiés sous
|
||
la forme d'articles de revue et de rapports techniques
|
||
dans~\cite{AGIMPP2014,AGIP2014,DBLP:journals/tcs/AzimiGIP15}.
|
||
|
||
\subsubsection{Grammaires de tableaux}
|
||
Les grammaires de tableaux représentent un système de réécriture des
|
||
tableaux --- des structures régulières dont les nœuds sont étiquettes
|
||
avec des symboles~\cite{FreundO14}. Tout comme les règles de
|
||
réécriture de chaînes de caractères, une règle de réécriture de
|
||
tableaux remplace un motif par un autre. Les grammaires de tableaux
|
||
sont ainsi un modèle similaire aux automates cellulaires qui eux aussi
|
||
sont plongés dans une structure régulière. Une différence importante
|
||
intervient au niveau de la sémantique : les règles de grammaires de
|
||
tableaux s'appliquent séquentiellement, ce qui ne fait évoluer qu'un
|
||
seul motif du tableau à la fois. De plus, un tableau peut ne pas
|
||
couvrir complètement la structure sous-jacente ; par exemple, un
|
||
tableau dans l'espace cartésien à deux dimensions peut contenir un
|
||
nombre fini de cellules non vides disposées dans une configuration
|
||
particulière, les autres cellules étant vides. Une règle de réécriture
|
||
de tableaux qui rajoute une nouvelle cellule peut s'appliquer à un
|
||
motif seulement si cette nouvelle cellule correspond à un
|
||
endroit vide dans le tableau d'origine.
|
||
|
||
Ma contribution à l'étude des grammaires de tableaux a consisté à
|
||
fournir une construction qui a permis de prouver la complétude
|
||
computationnelle d'une variante restreinte de ce modèle~\cite{DBLP:conf/uc/FernauFISS13}. Nous nous
|
||
sommes également intéressés à la combinaison de réécriture de tableaux
|
||
avec les structures à membranes ; nous avons montré que ce genre de
|
||
systèmes atteignent la complétude computationnelle avec des règles
|
||
restreintes et avec deux membranes seulement.
|
||
|
||
\subsubsection{Algèbre de modèles}
|
||
L'un des problèmes centraux dans l'étude de systèmes complexes et
|
||
celui de composition de
|
||
modèles~\cite{Chilton2014146,rozenbergzoom2014}. Un système complexe
|
||
en tant qu'entité du monde réel est représenté par son modèle qui doit
|
||
souvent refléter certains aspects de sa complexité. Une approche à sa
|
||
modélisation consiste en l'imitation directe de toutes les
|
||
caractéristiques pertinentes du système ; le modèle construit pourra
|
||
dans ce cas répliquer le comportement du système modélisé, mais ne
|
||
sera pas forcement facile à comprendre. C'est notamment le cas de
|
||
projets récents qui visent à prédire le phénotype d'une cellule
|
||
biologique à partir de son génotype~\cite{wholecell} : les modèles de
|
||
la cellule fournis par ces projets combinent de manière ad hoc
|
||
plusieurs modèles existants dans le but d'assurer une modélisation
|
||
fidèle ; cependant les raisons derrière la plupart de comportements
|
||
restent inexpliquées. L'un des buts d'une telle approche serait de
|
||
créer un moule de la cellule biologique qui pourrait être ensuite
|
||
utilisé pour tourner des simulations et pour éviter ainsi une partie
|
||
d'expériences in vitro qui sont coûteuses en temps et en ressources.
|
||
|
||
Étant données les difficultés qui surgissent au moment où l'on
|
||
voudrait utiliser plusieurs modèles pour analyser un système et la
|
||
non-transparence des modèles composés, il est très naturel de se
|
||
pencher sur une méthodologie générale de combinaison de
|
||
formalismes. Cette méthodologie est souvent appelée « algébre de
|
||
modèles ». L'article~\cite{Chilton2014146} en est un exemple
|
||
illustratif : les auteurs utilisent les {\em automates d'interface}
|
||
(interface automata) pour représenter un composant d'un modèle. Les
|
||
automates d'interface décrivent les traces d'évènements qui ont lieu
|
||
dans un système donné. Cette représentation axée sur le comportement
|
||
permet de définir des opérations de composition et de raffinement qui
|
||
préservent certaines propriétés dynamiques.
|
||
|
||
Dans nos travaux avec Antoine \textsc{Spicher} et Martin
|
||
\textsc{Potier}, nous avons appliqué les outils de la théorie des
|
||
catégories pour aller vers une algèbre (ou des algèbres) de
|
||
modèles. Cette approche généralise celle proposée
|
||
en~\cite{Chilton2014146} parce qu'elle ne se limite pas à une
|
||
description du comportement dynamique des systèmes modélisés et laisse
|
||
à l'utilisateur la liberté du choix de la description. Ainsi, nous
|
||
considérons une catégorie de descriptions de systèmes, avec comme
|
||
flèches les relations de validation. De manière informelle, une
|
||
description $a$ peut être validée par une autre $b$ si on arrive à «
|
||
retrouver » les détails de « a » dans « b ». Pour parler de la
|
||
modélisation, on fixera dans cette catégorie de descriptions et de
|
||
validations un objet de repère qui décrit le mieux possible le système
|
||
à modéliser et on définira ensuite une autre catégorie (une slice
|
||
catégorie) de descriptions munies de flèches de validation par l'objet
|
||
de repère. Cette catégorie sera donc la catégorie des {\em modèles}
|
||
du système que décrit l'objet de repère. Les flèches de cette
|
||
catégorie seront les flèches d'abstraction entre les modèles. Dans la
|
||
catégorie des modèles on pourra ensuite utiliser les limites et les
|
||
colimites pour définir des opérations concrètes.
|
||
|
||
Nos travaux sur l'approche catégorielle à la définition d'une algèbre
|
||
de modèle seront intégrés dans le manuscrit de thèse de Martin
|
||
\textsc{Potier} et publiés ensuite dans un article séparé.
|
||
|
||
Nous notons que l'usage des catégories et des slice catégories pour
|
||
une définition formelle de la modélisation tire, en parti, son
|
||
inspiration des travaux d'Andrée Ehressman~\cite{Ehressman12} sur les
|
||
processus évolutifs à mémoire.
|
||
|
||
\subsection{Projets de programmation}
|
||
Lors de mon parcours universitaire et doctoral j'ai réalisé plusieurs
|
||
projets de programmation aussi bien accessoires à mon activité de
|
||
recherche qu'indépendants. J'ai notamment contribué au système
|
||
d'exploitation libre à micro-noyau GNU/Hurd~\cite{Hurd}, qui est fondé
|
||
sur le principe des translateurs ({\em translator}) --- des
|
||
applications spéciales qui peuvent être installés par dessus certains
|
||
fichiers pour offrir une vue modifiée du contenu. J'ai développe un
|
||
translateur capable de monter plusieurs systèmes de fichiers sous un
|
||
seul dossier (montage union)~\cite{unionmount} et j'ai aussi travaillé
|
||
sur une extension du gestionnaire du système de fichiers qui
|
||
permettrait d'installer des translateurs en utilisant une syntaxe
|
||
étendue de chemins d'accès~\cite{nsmux}. Ce travail a été effectué
|
||
lors de l'édition 2009 de «~Google Summer of Code~».
|
||
|
||
Je me suis aussi intéressé aux modèles d'interaction asynchrone en
|
||
réseaux et je me suis proposé d'implémenter le modèle acteur ({\em
|
||
actor model}). Les entités centrales de ce modèle sont les acteurs
|
||
--- les processus qui s'exécutent en parallèle et qui possèdent des
|
||
boîtes à messages. Les acteurs peuvent s'envoyer des messages de façon
|
||
asynchrone, c'est-à-dire l'expéditeur n'attend pas que le message soit
|
||
reçu. Afin de rendre mon implémentation plus succincte et flexible, je
|
||
l'ai réalisée en le langage fonctionnel strictement typé Haskell.
|
||
|
||
Un autre projet de programmation non relié directement à mes pistes de
|
||
recherche principales était ma contribution au système de calcul
|
||
formel SymPy~\cite{sympy} qui à consisté à initier un module de
|
||
théorie des catégories~\cite{categories}. Je me suis concentré sur la
|
||
présentation informatique des diagrammes commutatifs --- un outil de
|
||
base en algèbre abstraite --- et j'ai programmé la mise en page
|
||
automatique d'un tel diagramme. J'ai travaillé ensuite sur un
|
||
algorithme de déduction automatique de la commutativité d'un diagramme
|
||
à partir d'un ensemble de diagrammes dits axiomes. Cette contribution
|
||
a été faite lors de l'édition 2012 de «~Google Summer of Code~».
|
||
|
||
Un de mes premiers projets afférents aux domaines de recherche dans
|
||
lesquels j'ai travaillé était le développement d'un simulateur de
|
||
systèmes à membranes capable de représenter la plupart des variation
|
||
du modèle en utilisant plusieurs moteurs de simulation. J'ai
|
||
implémenté un moteur OpenCL qui s'exécutait sur la carte graphique et
|
||
un autre, en Haskell, qui était moins performant mais offrait la
|
||
possibilité de faire tourner le système simulé pas à pas.
|
||
|
||
Un autre projet était d'automatiser la construction des réseaux de
|
||
Petri universels, ce qui m'a amené à la réalisation d'un ensemble
|
||
d'outils pour la gestion informatique de ces objets, ainsi que de
|
||
quelques autres objets connus de la théorie de la calculabité,
|
||
notamment les machines à registres. Une partie de ces outils est déjà
|
||
disponible en ligne~\cite{compdev} ; d'autres sont en état d'ébauche
|
||
et seront disponibles au public dès leur finalisation.
|
||
|
||
Finalement, afin de faciliter la conception et la vérification de
|
||
systèmes à réactions, j'ai implémenté un simulateur de ce modèle. Le
|
||
code source du simulateur, ainsi que la documentation, est disponible
|
||
en ligne~\cite{brsim}. J'ai aussi réalisé une interface
|
||
Web~\cite{brsimweb} qui permet d'utiliser mon simulateur sans à avoir
|
||
à télécharger et compiler le code.
|
||
|
||
\subsection{Relecture des articles scientifiques}
|
||
J'ai été rapporteur pour les revues suivantes : {\em Theoretical
|
||
Computer Science} (Elsevier), {\em Fundamenta Informaticae} (IOS
|
||
Press), {\em Lecture Notes for Computer Science} (Springer), {\em
|
||
Journal of Cellular Automata} (Old City Publishing). J'ai également
|
||
rapporté des articles pour plusieurs éditions de {\em International
|
||
Conference on Membrane Computing}.
|
||
|
||
\subsection{Projet de recherche}
|
||
Mon projet de recherche vise à appliquer l'expérience que j'ai acquise
|
||
en explorant les pistes énumérées dans les sections précédentes à
|
||
l'étude des systèmes complexes et notamment à la compréhension et à la
|
||
gestion de la complexité de ces systèmes. Ma stratégie consiste donc à
|
||
employer le savoir formel des structures mathématiques et
|
||
informatiques abstraites afin de construire des modèles qui, en plus
|
||
d'être rapprochés aux systèmes modélisés en ce qui concerne le
|
||
comportement, soient modulaires ou au moins explicables par découpage
|
||
en sous-parties.
|
||
|
||
Le but général que je me propose étant audacieux, il est important de
|
||
préciser que les travaux que je compte mener (et que j'ai déjà menés)
|
||
ont des applications concrètes dans les domaines respectifs. Autrement
|
||
dit, ma recherche vise d'abord à contribuer à la résolution d'un
|
||
problème concret et à en tirer des conclusions généralisatrices qui
|
||
peuvent être appliquées à d'autres situations et qui ont donc une
|
||
valeur en elles-mêmes.
|
||
|
||
Mon projet de recherche se compose de trois parties. La première se
|
||
focalise sur les sujets que j'ai abordés pendant mes études
|
||
doctorales, y compris ceux qui n'ont pas été présentés dans le
|
||
manuscrit de thèse. La deuxième partie consiste en l'étude des
|
||
structures algébriques et topologiques fondamentales afin de les
|
||
utiliser pour la conception des composants pour la construction
|
||
modulaire de modèles de systèmes complexes. La troisième partie se
|
||
focalise sur les implémentations logiciel de structures abstraites
|
||
dans le but d'utiliser la puissance de calcul des ordinateurs modernes
|
||
pour la simulation de systèmes et la vérification de modèles.
|
||
|
||
Les sous-sections suivantes donnent une vue plus détaillée sur les
|
||
trois parties de mon projet de recherche.
|
||
|
||
\subsubsection{Langages formels et calcul formel}
|
||
La plupart de contributions que j'ai faites pendant mon doctorat
|
||
s'inscrivent dans le domaine des langages formels et de l'étude
|
||
formelle du calcul. L'approche souvent adoptée dans ce domaine est de
|
||
traiter l'évolution dynamique de systèmes comme une suite de
|
||
configurations discrète, décrite par un langage formel. Dans cette
|
||
optique, le comportement d'un système peut être décrit pas des règles
|
||
de réécriture de chaînes de caractère formelles. Les deux types de
|
||
modèles de réécriture dont je compte approfondir ma compréhension sont
|
||
les systèmes d'insertion/effacement et les systèmes de réécriture de
|
||
multiensembles.
|
||
|
||
\paragraph{Insertion/effacement}
|
||
L'une des premières pistes que j'aborderais dans ce contexte sera la
|
||
continuation de l'étude des systèmes d'insertion/effacement avec des
|
||
contextes de petite taille, et particulièrement les systèmes dont
|
||
toutes les règles ne possèdent que le contexte à gauche. La complétude
|
||
(ou l'incomplétude) computationnelle de ces systèmes n'a toujours pas
|
||
été démontrée. Au delà de la complétude computationnelle qui n'est
|
||
qu'une caractérisation très approximative du comportement possible de
|
||
ces systèmes, il serait très intéressant d'étudier de plus près la dynamique
|
||
engendrée par les règles d'insertion et d'effacement. Je
|
||
voudrais notamment utiliser dans ce but les graphes de dérivation, qui
|
||
définissent un protocole de représentation graphique de dérivations,
|
||
qui code chaque insertion par un trait, et chaque effacement par
|
||
un trait pointillé.
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\vspace{2mm}
|
||
\begin{tikzpicture}[node distance=5pt and -20pt]
|
||
\node[nsymb] (x) {$\nbold x$};
|
||
|
||
% The symbols of the first red branch consisting of F-symbols.
|
||
\node[nsymb,below right=of x] (n1) {$\nbold F_1$};
|
||
\node[nsymb,below right=of n1] (n2) {$\nbold F_0$};
|
||
\node[nsymb,below right=of n2] (n3) {$\nbold F_1$};
|
||
\node[nsymb,below right=of n3] (n4) {$\nbold F_0$};
|
||
\node[nsymb,below right=of n4] (n5) {$\nbold F_1$};
|
||
\node[nsymb,below right=of n5] (n6) {$\nbold F_0$};
|
||
\node[nsymb,below right=of n6] (n7) {$\nbold F_1$};
|
||
\node[nsymb,below right=of n7] (n8) {$\nbold F_0$};
|
||
\node[nsymb,below right=of n8] (a01) {$\nbold a_0$};
|
||
|
||
% The first red branch itself.
|
||
\draw[insertion] (x) -- (n1) -- (n2) -- (n3) -- (n4) -- (n5) -- (n6)
|
||
-- (n7) -- (n8) -- (a01);
|
||
|
||
% The nodes of the leftmost green branch.
|
||
\node[nsymb,right=0 and 10pt of a01] (n9) {$\nlight X_{0,0}$};
|
||
\node[nsymb,above right=of n9] (n10) {$\nlight Y_{0,0}$};
|
||
\node[nsymb,above right=of n10] (n11) {$\nlight X_{0,1}$};
|
||
\node[nsymb,above right=of n11] (n12) {$\nlight Y_{0,1}$};
|
||
\node[nsymb,above right=of n12] (n13) {$\nlight X_{0,0}$};
|
||
\node[nsymb,above right=of n13] (n14) {$\nlight Y_{0,0}$};
|
||
\node[nsymb,above right=of n14] (n15) {$\nlight X_{0,1}$};
|
||
\node[nsymb,above right=of n15] (n16) {$\nlight Y_{0,1}$};
|
||
|
||
\node[nsymb] at ($(n16)+(16pt,20pt)$) (d1) {$\nbold D_{0,1}$};
|
||
|
||
% The deletions connecting together the leftmost green branch.
|
||
\draw[deletion] ($(a01)+(9pt,0)$) -- (n9);
|
||
\foreach \i / \j in {9/10, 10/11, 11/12, 12/13, 13/14, 14/15, 15/16} {
|
||
\draw[deletion] ($(n\i)+(-1pt,7pt)$) -- ($(n\j)+(-4.5pt,-7pt)$);
|
||
}
|
||
\draw[deletion] ($(n16)+(1pt,7pt)$) -- ($(d1)+(-10pt,-6pt)$);
|
||
|
||
% The insertions of the nodes on the leftmost green branch by the
|
||
% nodes on the leftmost red branch.
|
||
\foreach \i / \j in {8/9, 7/10, 6/11, 5/12, 4/13, 3/14, 2/15, 1/16} {
|
||
\draw[insertion,shorten >=-3pt, shorten <=-5pt] (n\i) -- (n\j);
|
||
}
|
||
\draw[insertion,shorten >=-3pt, shorten <=-7pt] (x) -- (d1);
|
||
|
||
% The nodes of the red branch starting at D_{0,1}.
|
||
\node[nsymb,below right=of d1] (n17) {$\nbold D_{0,0}$};
|
||
\node[nsymb,below right=of n17] (n18) {$\nbold D_{0,1}$};
|
||
\node[nsymb,below right=of n18] (n19) {$\nbold D_{0,0}$};
|
||
\node[nsymb] at ($(n19)+(3pt,-20pt)$) (b1) {$\nbold B_0$};
|
||
\node[nsymb,below right=of b1] (a11) {$\nbold a_1$};
|
||
|
||
% The red branch starting at D_{0,1} itself.
|
||
\foreach \i / \j in {d1/n17, n17/n18, n18/n19} {
|
||
\draw[insertion] ($(\i)+(-1.5pt,-6pt)$) -- ($(\j)+(-5pt,8pt)$);
|
||
}
|
||
\draw[insertion,shorten >=-1pt] ($(n19)+(0pt,-6pt)$) -- (b1) -- (a11);
|
||
|
||
% The deletions coming from the leftmost green branch over to the
|
||
% second red branch from the left.
|
||
\draw[deletion] ($(n10)+(4pt,5pt)$) to[out=28,in=-105] ($(n19)+(-5pt,-6pt)$);
|
||
\draw[deletion] ($(n12)+(5pt,6pt)$) to[out=28,in=-105] ($(n18)+(-6pt,-6pt)$);
|
||
\draw[deletion] ($(n14)+(4pt,5pt)$) to[out=28,in=-105] ($(n17)+(-6pt,-6pt)$);
|
||
\draw[deletion] ($(a01)+(3pt,-5pt)$) to[out=-35,in=-105] ($(b1)+(-4pt,-8pt)$);
|
||
|
||
% The nodes of the second leftmost green branch.
|
||
\node[nsymb] at ($(a11)+(19pt,19pt)$) (n20) {$\nlight X_{1,0}$};
|
||
\node[nsymb,above right=of n20] (n21) {$\nlight Y_{1,0}$};
|
||
\node[nsymb,above right=of n21] (n22) {$\nlight X_{1,1}$};
|
||
\node[nsymb,above right=of n22] (n23) {$\nlight Y_{1,1}$};
|
||
|
||
\node[nsymb] at ($(n23)+(16pt,19pt)$) (d2) {$\nbold D_{1,1}$};
|
||
|
||
% The deletions connecting together the second green branch.
|
||
\draw[deletion] ($(a11)+(6pt,4pt)$) -- ($(n20)+(-8pt,-6pt)$);
|
||
\foreach \i / \j in {20/21, 21/22, 22/23} {
|
||
\draw[deletion] ($(n\i)+(-2pt,7pt)$) -- ($(n\j)+(-5pt,-7pt)$);
|
||
}
|
||
\draw[deletion] ($(n23)+(1pt,7pt)$) -- ($(d2)+(-10pt,-6pt)$);
|
||
|
||
% The insertions of the nodes on the second leftmost green branch.
|
||
\foreach \i / \j in {19/20, 18/21, 17/22} {
|
||
\draw[insertion,shorten >=-2pt, shorten <=-2pt] (n\i) -- (n\j);
|
||
}
|
||
\draw[insertion,shorten >=-2pt, shorten <=-2pt] (d1) -- (n23);
|
||
\draw[insertion,shorten >=-3pt, shorten <=-7pt] (x) to[out=-5,in=172] (d2);
|
||
|
||
% The nodes of the third leftmost red branch.
|
||
\node[nsymb] at ($(d2)+(5pt,-19pt)$) (n24) {$\nbold D_{1,0}$};
|
||
\node[nsymb] at ($(n24)+(3pt,-19pt)$) (b2) {$\nbold B_1$};
|
||
\node[nsymb,below right=of b2] (a02) {$\nbold a_0$};
|
||
|
||
% The red branch itself.
|
||
\draw[insertion] ($(d2)+(-1.5pt,-6pt)$) -- ($(n24)+(-5pt,8pt)$);
|
||
\draw[insertion,shorten >=-1pt] ($(n24)+(0pt,-6pt)$) -- (b2) -- (a02);
|
||
|
||
% The deletions of symbols on the third leftmost red branch.
|
||
\draw[deletion] ($(n21)+(4pt,5pt)$) to[out=28,in=-105] ($(n24)+(-5pt,-6pt)$);
|
||
\draw[deletion] ($(a11)+(8pt,1pt)$) to[out=15,in=-105] ($(b2)+(-3pt,-6pt)$);
|
||
|
||
% The symbols of the rightmost green branch.
|
||
\node[nsymb] at ($(a02)+(19pt,19pt)$) (n25) {$\nlight X_{0,0}$};
|
||
\node[nsymb,above right=of n25] (n26) {$\nlight Y_{0,0}$};
|
||
|
||
\node[nsymb] at ($(n26)+(16pt,19pt)$) (d3) {$\nbold D_{0,0}$};
|
||
|
||
% The deletions connecting the rightmost green branch together.
|
||
\draw[deletion] ($(a02)+(6pt,4pt)$) -- ($(n25)+(-8pt,-6pt)$);
|
||
\draw[deletion] ($(n25)+(-2pt,7pt)$) -- ($(n26)+(-4.5pt,-7pt)$);
|
||
\draw[deletion] ($(n26)+(1pt,7pt)$) -- ($(d3)+(-10pt,-6pt)$);
|
||
|
||
% The insertions of the symbols on the rightmost green branch.
|
||
\draw[insertion,shorten >=-2pt, shorten <=-2pt] (n24) -- (n25);
|
||
\draw[insertion,shorten >=-2pt, shorten <=-2pt] (d2) -- (n26);
|
||
\draw[insertion,shorten >=-3pt, shorten <=-7pt] (x) to[out=-3,in=170] (d3);
|
||
|
||
% The rightmost red branch.
|
||
\node[nsymb] at ($(d3)+(4pt,-18pt)$) (b3) {$\nbold B_0$};
|
||
\node[nsymb,below right=of b3] (a12) {$\nbold a_1$};
|
||
|
||
% The rightmost red branch itself.
|
||
\draw[insertion,shorten >=-1pt] ($(d3)+(0pt,-6pt)$) -- (b3) -- (a12);
|
||
|
||
% The deletions of symbols on the rightmost red branch.
|
||
\draw[deletion] ($(a02)+(8pt,1pt)$) to[out=15,in=-105] ($(b3)+(-3pt,-6pt)$);
|
||
\end{tikzpicture}
|
||
\vspace{-7mm}
|
||
\caption{Un graphe de dérivation pour un système
|
||
d'insertion/effacement de taille $(1,1,0; 1,1,0)$ qui engendre un
|
||
langage non-algébrique~\cite[Section~8]{JL2005}}
|
||
\label{fig:insdel:lft-2n}
|
||
\end{figure}
|
||
|
||
La figure~\ref{fig:insdel:lft-2n} montre un exemple de comportement
|
||
dynamique que peut avoir un système d'in\-ser\-tion/ef\-face\-ment
|
||
avec des règles qui n'insèrent et n'effacent qu'un symbole à la fois
|
||
et qui vérifient uniquement les contextes à gauche (des règles de
|
||
taille $(1,1,0; 1,1,0)$). Il s'agit du système décrit
|
||
dans~\cite[Section~8]{JL2005} qui possède un taux de croissance
|
||
exponentiel et qui engendre donc un langage non-algébrique. Dans la
|
||
figure~\ref{fig:insdel:lft-2n} nous avions mis en gras les symboles
|
||
terminaux ainsi que tous les symboles qui insèrent des symboles
|
||
gras. Avec ce code couleur on voit immédiatement que le graphe
|
||
correspondant à une dérivation de ce système consiste en des chemins
|
||
gras qui interagissent par le biais de structures gris clair. En
|
||
outre, on remarque la croissance exponentielle des chemins gras, de
|
||
droite à gauche : effectivement, le chemin gras de droite contient un
|
||
symbole $D$, celui d'avant en contient 2, le troisième chemin de
|
||
droite contient 4 symboles $D$, alors que le chemin gras tout à
|
||
gauche contient déjà 8 symboles $F$.
|
||
|
||
Nous tirons deux conclusions de cette analyse superficielle de la
|
||
figure~\ref{fig:insdel:lft-2n}. D'un côté, on observe que les règles
|
||
d'insertion et d'effacement de petite taille peuvent avoir un
|
||
comportement assez complexe qui dépasse même la puissance de
|
||
modélisation des automates à pile. D'un autre côté, on note
|
||
l'efficacité visuelle des graphes de dérivation qui offrent une vue
|
||
d'ensemble sur une dérivation sans perdre les détails dynamiques
|
||
essentiels, c'est-à-dire les éléments de comportement qui ont une
|
||
influence sur le langage engendré. Cette propriété des graphes de
|
||
dérivation les rend très intéressants pour toute étude de la dynamique
|
||
des systèmes d'insertion/effacement.
|
||
|
||
\paragraph{Réécriture de multiensembles}
|
||
La réécriture de multiensembles, et notamment les systèmes à
|
||
membranes, est le domaine dans lequel j'ai fait mes plus anciennes
|
||
contributions scientifiques et dont plusieurs questions continuent à
|
||
m'intéresser à présent. Dans la continuité des travaux menés pendant
|
||
mon doctorat, je voudrais poursuivre l'étude du problème de
|
||
l'universalité pour ce modèle et en particulier l'étude des techniques
|
||
d'optimisations de la taille des systèmes universels.
|
||
|
||
D'un autre côté, je voudrais me concentrer plus sur l'étude de
|
||
systèmes à membranes avec des règles dynamiques, dites polymorphes,
|
||
que nous avions introduits dans~\cite{AI2011} et dont une variante
|
||
restreinte j'ai étudiée dans~\cite{DBLP:conf/membrane/Ivanov14}. Le
|
||
comportement de ces systèmes ressemble au celui de cellules vivantes
|
||
dans le fait que les règles qui dirigent l'évolution peuvent être
|
||
modifiées, ce qui donne une dimension de dynamisme en plus. En outre, le
|
||
polymorphisme complexifie le rapport entre les étapes consécutives
|
||
d'évolution, car une configuration du système détermine non seulement
|
||
la configuration suivante, mais aussi la forme des règles qui seront
|
||
utilisées plus tard dans l'évolution.
|
||
|
||
La figure~\ref{fig:superexponential-growth} montre un exemple d'un
|
||
système polymorphe qui possède un taux de croissance
|
||
super-exponentiel. Ce système a deux règles : la première qui a
|
||
initialement la forme $a\to a$, et la deuxième qui ne varie pas et qui
|
||
double le nombre de $a$ dans la partie droite de la première
|
||
règle. Ainsi, après $k$ pas d'évolution, la première règle aura la
|
||
forme $a\to a^{2^{k}}$. Par conséquence, après le même nombre de pas,
|
||
la membrane extérieure du système contiendra $2^{\frac{k(k-1)}{2}}$
|
||
copies de $a$.
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\vspace{2mm}
|
||
\begin{tikzpicture}
|
||
\node (r2) {$2:a\to aa$};
|
||
\node[below=.1 of r2] (w1L) {$a$};
|
||
|
||
\membrane{$1R$}{1R}{}{fit={(r2) (w1L)}}
|
||
\membrane{$1L$}{1L}{$a$}{below left=-15.5pt and 13pt of 1R}
|
||
\node[below left=5pt and -25pt of 1R] (ws) {$a$};
|
||
|
||
\membrane{$s$}{s}{}{fit={(1L) (1L label) (1R) (1R label) (ws)}}
|
||
\end{tikzpicture}
|
||
\caption{Un P système polymorphe avec un taux de croissance
|
||
super-exponentiel}
|
||
\label{fig:superexponential-growth}
|
||
\end{figure}
|
||
|
||
On remarque deux pistes d'exploration possibles pour les systèmes à
|
||
membranes polymorphes. La première reste dans le cadre de l'étude
|
||
formelle et se focalise sur le rapport entre les restrictions que l'on
|
||
peut imposer statiquement et le comportement dynamique des systèmes
|
||
avec ces restrictions, particulièrement leur puissance de calcul. La
|
||
deuxième piste mène vers une collaboration interdisciplinaire et
|
||
consiste à trouver des parallèles entre la complexité induite par le
|
||
polymorphisme et la complexité intrinsèque des systèmes complexes tels
|
||
que l'on trouve en biologie, en physique, etc. De telles parallèles
|
||
permettrait d'approfondir la compréhension de cette complexité et
|
||
suggérerait des manières de la gérer.
|
||
|
||
Une autre direction majeure de recherche qui m'attire fortement est la
|
||
conception de cadres généraux pour réunir plusieurs variantes de
|
||
systèmes à membranes. Étant donnée la variété importante de variantes
|
||
de ces systèmes, avoir des cadres généraux permet tout d'abord
|
||
d'unifier la terminologie qui est souvent dérivée de diverses domaines
|
||
de la biologie et donc hétérogène. Deuxièmement, cette unification
|
||
offre souvent des perspectives très éclairantes sur les combinaisons
|
||
possibles d'ingrédients qui n'ont pas encore été étudiées.
|
||
|
||
\paragraph{Autres modèles de calcul} En plus des deux modèles de
|
||
calculs déjà mentionnés dans cette sous-section, je voudrais en
|
||
continuer l'exploration d'autres ayant des liens de parenté forts avec
|
||
les systèmes d'insertion/effacement et avec la réécriture de
|
||
multiensembles. Ainsi, je suis intéressé par les machines à registres
|
||
universelles de petite taille et je voudrais travailler sur la
|
||
réduction de la taille des
|
||
constructions existantes. Cela permettrait d'améliorer les systèmes à
|
||
membranes universels en réduisant le nombre de règles, de symboles, ou
|
||
d'autres ingrédients utilisés.
|
||
|
||
Je voudrais également continuer l'étude de réseaux de processeurs
|
||
évolutionnaires, mais au lieu de me pencher sur la caractérisation de
|
||
leur puissance d'expression je m'intéresserais plutôt à la dimension
|
||
parallèle inhérente à ce modèle de calcul. Je voudrais notamment
|
||
explorer le lien entre les réseaux de processeurs évolutionnaires et
|
||
les systèmes à membranes ; en effet, dans les cas des deux modèles on
|
||
retrouve des processeurs qui échangent des données en réseau. Un autre
|
||
trait commun est la possibilité de distinguer deux types de
|
||
parallélisme : d'une part, le traitement des données dans un
|
||
processeur se fait de façon parallèle ; d'autre part, l'activité des
|
||
processeurs eux-mêmes se déroule parallèlement, avec une barrière de
|
||
synchronisation globale s'imposant à chaque étape d'évolution. Il me
|
||
paraît intéressant de concevoir un cadre général pour ces deux modèles
|
||
afin d'explorer à un haut niveau d'abstraction les manières
|
||
différentes dont le calcul parallèle pourrait être organisé. En plus,
|
||
ce cadre généralisant pourrait indiquer d'autres membres de la famille
|
||
de modèles de calcul dont les réseaux de processeurs évolutionnaires
|
||
et les systèmes à membranes font partie.
|
||
|
||
Encore un modèle de calcul intrinsèquement parallèle qui m'attire
|
||
fortement sont les automates cellulaires, qui représentent
|
||
essentiellement des grilles d'automates finis qui communiquent. Les
|
||
automates dans les nœuds de la grille n'ont pas de bande, donc la
|
||
seule information dont ils peuvent disposer est leur état et les états
|
||
des voisins dans un voisinage défini statiquement. Les unités
|
||
atomiques de calcul des automates cellulaires sont ainsi moins
|
||
puissantes que les processeurs dans les réseaux de processeurs
|
||
évolutionnaires ou les membranes dans les systèmes à membranes ;
|
||
néanmoins, en terme de pouvoir d'expression les automates cellulaires
|
||
sont équivalents aux machines de Turing. On observe donc un
|
||
considérable écart entre l'expressivité globale d'un automate
|
||
cellulaire et l'expressivité locale de chaque unité. Par conséquent,
|
||
ce modèle de calcul semble être un contexte bien adapté à l'étude de
|
||
rapports entre les comportements locaux et globaux de systèmes
|
||
complexes. En effet, des travaux ont déjà été menés dans cette
|
||
direction (\cite{DBLP:conf/pads/PotierSM13}, par exemple) ; je
|
||
voudrais appliquer l'expérience que j'ai acquise pour contribuer à ces
|
||
études.
|
||
|
||
\subsubsection{Algèbres de modèles}
|
||
L'un des problèmes centraux dans l'étude de systèmes complexes et
|
||
celui de composition de
|
||
modèles~\cite{Chilton2014146,rozenbergzoom2014}. Un système complexe
|
||
en tant qu'entité du monde réel est représenté par son modèle qui doit
|
||
souvent refléter certains aspects de sa complexité. On peut distinguer
|
||
deux approches à la représentation de la complexité. La première
|
||
consiste en l'imitation directe de toutes les caractéristiques
|
||
pertinentes du système ; le modèle construit pourra dans ce cas
|
||
répliquer le comportement du système modélisé, mais ne sera pas
|
||
forcement facile à comprendre. C'est notamment le cas de projets
|
||
récents qui visent à prédire le phénotype d'une cellule biologique à
|
||
partir de son génotype~\cite{wholecell} : les modèles de la cellule
|
||
fournis par ces projets combinent de manière ad hoc plusieurs modèles
|
||
existants dans le but d'assurer une modélisation fidèle ; cependant
|
||
les raisons derrière la plupart de comportements restent
|
||
inexpliquées. L'un des buts d'une telle approche serait de créer un
|
||
moule de la cellule biologique qui pourrait être ensuite utilisé pour
|
||
tourner des simulations et pour éviter ainsi une partie d'expériences
|
||
in vitro qui sont coûteuses et de longue durée.
|
||
|
||
L'autre approche à la représentation de la complexité est de modéliser
|
||
certaines propriétés locales nécessaires pour que le comportement
|
||
globale du modèle corresponde à celui du système. Cette approche
|
||
pourrait offrir une vue beaucoup plus détaillée sur les liens entre
|
||
les causes et les effets dans le système, et donnerait dans l'idéal
|
||
des façons de décomposer le modèle en sous-parties modulaires,
|
||
c'est-à-dire des parties dont on espérerait trouver les homologues
|
||
dans les modèles des autres systèmes. Toutefois, il est clair que ce
|
||
type d'analyse nécessite une compréhension plus profonde du système à
|
||
modéliser mais aussi des techniques de modélisation. Je souhaiterais
|
||
me concentrer sur ces techniques et travailler vers la formulation de
|
||
véritables algèbres de modèles, dans le cadre desquelles on pourrait
|
||
construire des modèles plus complexes à partir des plus simples, mais
|
||
aussi retrouver des blocs en lesquels un modèle existant peut être
|
||
décomposé.
|
||
|
||
Des résultats très intéressants sur un outil formel de combinaison de
|
||
modèles ont été présentés dans~\cite{Chilton2014146}. L'article
|
||
utilise les {\em automates d'interface} (interface automata) pour
|
||
représenter un composant d'un modèle. Un automate d'interface est
|
||
défini comme un alphabet d'événements d'entrée, un alphabet
|
||
d'événements de sortie, un ensemble de chaînes sur les deux alphabets
|
||
qui décrit les suites d'interactions possibles entre l'automate et
|
||
l'environnement, ainsi qu'un ensemble de chaînes qui mène l'automate
|
||
vers un état d'erreur. Une relation de raffinement est définie pour
|
||
les automates d'interface et ensuite des opérations de composition
|
||
sont introduites de sorte à être compatibles avec la relation de
|
||
raffinement.
|
||
|
||
La définition d'un automate d'interface étant très générale, les
|
||
propriétés démontrées dans~\cite{Chilton2014146} sont applicables à
|
||
une classe très large de modèles. Malheureusement, cette généricité
|
||
implique aussi que l'on ne peut déduire que des conclusions assez
|
||
générales pour être applicables à toute situation. Ce problème est
|
||
fort difficile à contourner, car il est inhérent à tout langage
|
||
générique. Je suis néanmoins convaincu qu'un langage riche permettant
|
||
non seulement d'exprimer des propriétés à un haut niveau
|
||
d'abstraction, mais aussi de décrire des objets spécialisés, peut
|
||
donner des indices sur la résolution du problème de généricité. Dans
|
||
ma recherche je compte utiliser la théorie des catégories comme un tel
|
||
langage.
|
||
|
||
Une catégorie est l'un des formalismes qui abstraient la notion de
|
||
structure mathématique elle-même. Une catégorie est défini comme une
|
||
collection d'« objets » et de « flèches » entre les objets, aucune
|
||
restriction n'étant imposée sur ce qu'un « objet » peut être, alors
|
||
que les flèches doivent respecter quelques propriétés de composition
|
||
basiques. (La monographie~\cite{Adamek04} peut servir de référence.)
|
||
En plus d'être très générale, la terminologie de la théorie des
|
||
catégories admet des intuitions graphiques naturelles.
|
||
|
||
Malgré sa généralité, le langage des catégories permet de construire
|
||
certains objets non-triviaux. Par exemple, la figure~\ref{fig:prod}
|
||
défini l'objet produit $X_1\times X_2$ pour des objets $X_1$ et $X_2$
|
||
d'une catégorie quelconque. Dans la catégorie des ensembles, le
|
||
produit correspond au produit cartésien, dans la catégorie des groupes
|
||
le produit correspond au produit direct, etc. La figure~\ref{fig:prod}
|
||
définit le produit $X_1\times X_2$ comme un objet avec deux flèches
|
||
$\pi_1$ et $\pi_2$ qui vont vers $X_1$ et $X_2$ respectivement, tel
|
||
que si l'on prend n'importe quel autre objet $Y$ avec deux flèches $f_1$
|
||
et $f_2$ vers $X_1$ et $X_2$, il existe une seule flèche de $Y$ vers
|
||
$X_1\times X_2$ telle que $\pi_1\circ f = f_1$ et $\pi_2 \circ f =
|
||
f_2$ (le diagramme est dit commutatif dans ce cas).
|
||
|
||
\begin{figure}[h]
|
||
\centering
|
||
\begin{tikzpicture}[node distance=9mm]
|
||
\node (y) {$Y$};
|
||
\node[below=of y] (x1x2) {$X_1\times X_2$};
|
||
\node[base left=of x1x2] (x1) {$X_1$};
|
||
\node[base right=of x1x2] (x2) {$X_2$};
|
||
|
||
\draw[->] (y) -- node[midway,auto,swap] {$f_1$} (x1);
|
||
\draw[->] (x1x2) -- node[midway,auto] {$\pi_1$} (x1);
|
||
\draw[->] (y) -- node[midway,auto] {$f_2$} (x2);
|
||
\draw[->] (x1x2) -- node[midway,auto,swap] {$\pi_2$} (x2);
|
||
\draw[->,dashed] (y) -- node[pos=.65,auto] {$\exists! f$} (x1x2);
|
||
\end{tikzpicture}
|
||
\caption{La définition d'un produit dans une catégorie}
|
||
\label{fig:prod}
|
||
\end{figure}
|
||
|
||
Il existe d'autres façons de construire des objets composés qui, grâce
|
||
à la généralité des catégories, pourraient être appliquées à des
|
||
modèles très différents. L'avantage de l'approche catégorielle par
|
||
rapport à celle proposée dans~\cite{Chilton2014146} seraient que, dans
|
||
la théorie des catégories, il est aussi possible de préciser
|
||
formellement quelles propriétés une catégories devrait avoir pour
|
||
qu'une certaine manière de composer les objets soit
|
||
faisable. Autrement dit, le langage des catégories est assez riche
|
||
pour pouvoir formuler des propriétés concernant des
|
||
classes vastes d'objets aussi bien que des propriétés bien concrètes,
|
||
valables dans certains cas particuliers uniquement. Je souhaite donc
|
||
m'investir dans l'exploration des possibilités d'appliquer l'approche
|
||
catégorielle à la composition de modèles afin de contribuer à l'étude
|
||
de systèmes complexes.
|
||
|
||
\subsubsection{Programmation algébrique}
|
||
En plus d'être génériques et flexibles, les structures catégorielles
|
||
et, plus généralement, algébriques et topologiques se fondent sur des
|
||
systèmes d'axiomes assez minimaux, ce qui rend leur représentation sur
|
||
l'ordinateur assez naturelle. Il ne s'agit pas de la correspondance
|
||
entre le modèle de calcul derrière les ordinateurs modernes qui n'est
|
||
certainement pas particulièrement adapté au calcul symbolique, mais
|
||
plutôt du fait que les systèmes d'axiomes minimaux se prêtent
|
||
facilement à une description sous la forme d'une spécification qui
|
||
peut être utilisée ensuite pour de la validation automatique. Ainsi,
|
||
la pratique d'incorporer certains aspect catégorielles dans le
|
||
systèmes de typage se voit de plus en plus adoptée par les
|
||
développeurs de langages de programmation.
|
||
|
||
Un exemple de langage qui a incorporé un nombre important de concepts
|
||
catégoriels est Haskell~\cite{haskellorg}. Ce langage permet de
|
||
manipuler directement des structures telles que monoïdes, foncteurs,
|
||
monades, etc. afin de pouvoir spécifier des propriétés assez fortes
|
||
sur les types, et notamment de factoriser les structures de données
|
||
utilisées ainsi que le code source. Il s'agit donc d'un travail de
|
||
découpage des structures de données et du code source en sous-parties,
|
||
ce qui est un cas particulier du problème général de décomposition de
|
||
modèles décrit dans la section précédente. Par conséquent, je trouve
|
||
très intéressant de représenter toute ébauche de théorie algébrique de
|
||
modèles sur l'ordinateur dans un langage haut niveau, car cela
|
||
permettra d'une part de vérifier la justesse des définitions et de les
|
||
tester en exécution assez tôt, et d'autre part de s'inspirer de
|
||
l'étude formelle derrière les langages haut niveau pour attaquer les
|
||
problèmes de modélisation de systèmes complexes.
|
||
|
||
\printbibliography[resetnumbers=true]
|
||
\end{refsection}
|
||
|
||
%%% Local Variables:
|
||
%%% mode: LaTeX
|
||
%%% mode: auto-fill
|
||
%%% ispell-local-dictionary: "fr"
|
||
%%% End:
|