\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. Dans cette section, je résume d'abord ma thèse, puis d'autres
résultats obtenus pendant mon doctorat et par la suite de ma carrière
scientifique.

\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 et postdoctoraux}
Avant le début de ma thèse et pendant mon doctorat j'ai travaillé sur
des problèmes qui n'étaient pas directement lié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.  En
tant que postdoc, je travaille sur la modélisation biomécanique du
squelette cellulaire.

Dans les sections suivantes, je donne plus détails par rapport aux
travaux de recherche sus-cités.

\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, 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.

Lors de ma visite en Finlande au printemps 2014, j'ai implémenté un
simulateur des systèmes à réactions afin de faciliter leur conception
et leur vérification. 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.

Finalement, ma mission en tant que chercheur postdoctoral comprend une
partie considérable de programmation.  Ils s'agit du développement
d'une solution logicielle pour la modélisation biomécanique du
squelette cellulaire, avec intégration ultérieure dans un framework de
modélisation biologique générique.  Ce projet se réalise en C++ parce
que le public visé (le modélisateurs de systèmes biologiques) est
confortable avec le langage C et parce que C++ offre un grand éventail
de techniques de représentation optimisée de concepts abstraits.

\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: