Vérification partielle de programmes de contrôle-commande

Transcription

R ECHERCHE
Vérification partielle de programmes
de contrôle-commande par interprétation
abstraite
Olivier Bouissou
CEA, LIST, Boîte courrier 94
F-91191 Gif-sur-Yvette cedex
[email protected]
L’analyse statique par interprétation abstraite cherche à sur-approximer l’ensemble
des comportements possibles des programmes pour s’assurer de l’absence de certains types de
bogues. Dans le cas des programmes de contrôle-commande, le comportement du programme
dépend de l’environnement extérieur avec lequel il interagit. Prendre en compte cet environnement, souvent largement sur-approximé dans les analyseurs, permet de prouver de nouvelles
propriétés concernant le programme de contrôle-commande. Dans cet article, nous nous intéressons à une classe de programme de contrôle-commande pour laquelle une description
de l’environnement physique existe sous forme d’équations différentielles. Nous décrivons de
nouvelles méthodes d’analyse de ces systèmes qui sur-approximent l’ensemble des trajectoires
possibles pour l’environnement continu, permettant ainsi de prouver, dans certains cas, des propriétés de sûreté sur l’algorithme de contrôle-commande.
RÉSUMÉ.
ABSTRACT. In
the field of static analysis, abstract interpretation based techniques compute over
approximations of the set of possible behaviors of programs. These over-approximations give
properties on the program that can be used to prove the abscence of some bugs. In the case
of control command programs, the behavior of the program depends on the physical environment with which it interacts. This environment is often largely over-approximated in classical
analyzers, taking it into account can lead to proving new properties conerning the controlcommand program. In this article, we consider a class of control-command programs for which
a description of the physical environment is given as a set of differential equations. We present
new analysis methods that over-approximate the set of possible trajectories for the continuous
environment. This allows to prove, in some cases, safety properties on the control-command
algorithm.
MOTS-CLÉS : analyse
KEYWORDS: static
statique, interprétation abstraite, systèmes hybrides, contrôle commande.
analysis, abstract interpretation, hybrid systems, control-command.
c 2012 Lavoisier
DOI:10.3166/TSI.31.337-373 Technique et science informatiques – no 3/2012, 337-373
338
TSI. Volume 31 – no 3/2012
1. Introduction
Les progrès de miniaturisation et d’encapsulation des composants électroniques
ont permis le déploiement à grande échelle de l’informatique dans les systèmes embarqués industriels, que ce soit dans le domaine de l’aéronautique, de l’automobile,
du ferroviaire ou encore du nucléaire. Si ce déploiement a permis d’augmenter fortement la sécurité de ces systèmes, il a induit de nouveaux risques liés aux défaillances
potentielles de ces programmes. En effet, les décisions critiques sont désormais souvent prises par un programme, et une erreur dans son fonctionnement peut avoir des
conséquences dramatiques. Pour vérifier l’absence de défaillances (ou bogues) d’un
programme, la théorie de l’analyse statique par interprétation abstraite (Cousot, Cousot, 1977 ; 1992a) utilise une notion de sur-approximation : on calcule pour chaque
variable du programme un ensemble contenant au moins toutes les valeurs qu’elle
peut prendre lors de l’exécution du programme. Ainsi, on pourra prouver l’absence
de certains types d’erreurs : si aucune de ces valeurs ne crée de division par zéro (par
exemple), cela signifiera qu’aucune exécution du programme ne pourra se terminer
par une division par zéro. Nous donnons en section 2.1 une introduction plus formelle
à l’interprétation abstraite. Remarquons cependant dès maintenant une des caractéristiques principales de cette technique : elle est par nature incomplète. En effet, prouver l’absence de bogues pour n’importe quel programme est indécidable. L’analyse
statique par interprétation abstraite ne pourra donc apporter la preuve de l’absence
d’un bogue que pour certains programmes. Dans les autres cas, il y aura une fausse
alarme, c’est-à-dire que l’analyse conclura à la présence potentielle d’un bogue alors
qu’il n’existe pas. Un des enjeux majeurs de l’interprétation abstraite est de réduire le
nombre de ces fausses alarmes. Les techniques que nous présentons dans cet article
souffrent du même problème, nous essayons de montrer tout au long de l’article où et
pourquoi ces fausses alarmes apparaissent.
Dans le cas de programmes de contrôle-commande embarqués, le calcul de la surapproximation des valeurs des variables est rendu plus complexe par les interactions
entre le programme et son environnement continu. En effet, ces programmes reçoivent
des données depuis un système physique via des capteurs et modifient la dynamique
de ce système via des actionneurs. Par exemple, pour un contrôleur automatique de
vitesse, les entrées sont fournies par un capteur indiquant la vitesse instantanée du véhicule, et le programme doit calculer la puissance moteur nécessaire pour atteindre et
maintenir la vitesse désirée. Ce type de programmes est donc très particulier : son comportement dépend fortement de l’environnement extérieur avec lequel il interagit, et il
n’est pas seulement nécessaire de s’assurer que le programme ne crée pas de bogues
(division par zéro par exemple) : il est également nécessaire de vérifier que l’environnement physique se comporte comme attendu. Par exemple, nous voulons prouver
que la vitesse du véhicule se stabilise à la vitesse désirée. Bien sûr, nous ne pouvons
pas vérifier cela sur l’environnement physique exact du système (pour un avion, cet
environnement serait l’atmosphère terrestre), nous choisissons donc un modèle de cet
environnement sous forme d’équations différentielles et nous vérifions que ce modèle
se comporte comme voulu. Nous n’étudions pas ici la pertinence du modèle par rap-
Vérification de programmes de contrôle-commande
339
port au milieu physique, il existe clairement des différences mais leur étude dépasse
le cadre de cet article. Dans la suite, nous identifions donc l’environnement physique
d’un programme de contrôle-commande avec son modèle donné sous forme d’équations différentielles, et nous essaierons de vérifier le bon comportement de ce modèle.
Nous détaillons ces idées en section 2.2.
Lorsqu’on s’intéresse aux programmes de contrôle-commande embarqués, on voit
donc qu’il est nécessaire de considérer l’ensemble des interactions possibles entre
le programme et son environnement. Ceci pose un problème majeur : le programme
a une évolution discrète alors que l’environnement est régi par des lois physiques
continues. Nous devons donc traiter des systèmes dits hybrides qui mélangent évolution discrète et évolution continue. C’est cette réflexion qui a motivé mon travail de
thèse (Bouissou, 2008) dans laquelle nous étendons les analyses statiques classiques
pour prendre en compte l’environnement physique avec lequel un programme embarqué interagit. Cet article présente certains des résultats issus de cette thèse. Ces
résultats permettent à la fois de prouver de nouvelles propriétés sur les programmes
de contrôle-commande et d’améliorer la précision (i.e. réduire le nombre de fausses
alarmes) des analyses classiques. Comme souvent, la méthode que nous proposons
n’est pas complète, c’est-à-dire qu’elle ne permet de prouver des propriétés de sûreté
que pour une classe restreinte de programmes. Nous détaillons maintenant les caractéristiques principales des programmes que nous pouvons prendre en compte :
– le contrôle est binaire, c’est-à-dire que le programme ne peut modifier l’environnement continu que via des actions discrètes : ouvrir ou fermer une vanne par exemple.
Les algorithmes de contrôle dits « bang-bang control » rentrent dans cette catégorie ;
– les capteurs et les actionneurs sont parfaits, c’est-à-dire que nous faisons l’hypothèse qu’il n’y a pas de délais d’écriture sur les actionneurs et pas de bruit de lecture
sur les capteurs. Cette hypothèse nous permet d’avoir un modèle relativement simple
des interactions entre un programme et son environnement physique, et nous permet
donc de garder une complexité raisonnable pour le calcul des trajectoires de l’environnement continu ;
– nous ne considérons pas le contrôle stochastique. Les programmes que nous
prenons en compte sont purement déterministes, l’extension de ces techniques à des
modèles mixant probabilisme (induit par le programme) et non-déterminisme (induit
par l’analyse) est en cours via le projet ANR CPP (Bouissou, Goubault et al., 2012).
Nous faisons à la section 4 une autre hypothèse sur les programmes de contrôlecommande que nous considérons, à savoir que leur comportement suit une boucle
« Lire-Calculer-Écrire » (voir section 2.2). Nous discuterons de cette hypothèse et des
restrictions qu’elle impose sur les programmes en début de section 4.
Pour illustrer nos propos, nous utilisons dans cet article un exemple de système de
contrôle-commande bien connu de la communauté des systèmes hybrides : le système
des deux réservoirs (Henzinger et al., 2000). Nous donnons à la figure 1(a) une vision
schématique de ce système, nous en donnons en section 3 une version plus formelle.
Ce système est composé de deux réservoirs (R1 et R2 ) reliés par une canalisation
340
C1
V1 , V2 ouvertes
√
h˙1 = i − k1 h1
h1
R1
V2 fermée
C12
√
h˙1 = i − k1 h1
V1
√
h˙2 = k1 h1
V1 fermée
h˙1 = i
h2
C2
R2
[tb]
√
√
h˙2 = k1 h1 − k2 h2
V2
(a) Un schéma du système
√
h˙2 = −k2 h2
V1 , V2 fermées
h˙1 = i
h˙2 = 0
(b) Les équations correspondantes
Figure 1. Le système des deux réservoirs
(C12 ) horizontale située à la base du réservoir R1 . De l’eau entre dans le système
par une arrivée (C1 ) constante dans le réservoir R1 et l’eau peut quitter le système
par une canalisation (C2 ) située à la base du réservoir R2 . Les canalisations C12 et
C2 sont munies de vannes (V1 et V2 , respectivement) permettant de laisser passer, ou
non, l’eau dans les canalisations. L’évolution temporelle des hauteurs d’eau h1 et h2
dans les réservoirs R1 et R2 , respectivement, est donnée (en fonction de l’état des
vannes V1 et V2 ) par les équations différentielles de la figure 1(b) ; dans ces équations,
i est le débit d’arrivée d’eau dans la canalisation C1 , k1 et k2 sont des coefficients
représentant la section des canalisations C12 et C2 , respectivement.
Cet article est organisé comme suit. La section 2 formalise la théorie de l’interprétation abstraite et la notion de logiciel de contrôle-commande. Dans la section 3, nous
décrivons notre modèle pour décrire les programmes de contrôle-commande et donnons, brièvement, un aperçu de leur sémantique. Puis, dans les sections 4 et 5 nous décrivons une technique d’analyse permettant de calculer des bornes sur les trajectoires
continues pour ce type de programme. Les sections 6 et 7 présentent, respectivement,
les travaux connexes et les conclusions.
Remarquons que pour plus de clarté, nous ne donnons pas dans cet article les
preuves des résultats, elles sont présentes dans la thèse (Bouissou, 2008).
2. Contexte
2.1. Vérification de programmes par interprétation abstraite
L’interprétation abstraite est une technique automatique permettant de prouver
l’absence d’un certain type d’erreurs d’un programme P portant sur un ensemble
341
fini de variable V = {x1 , . . . , xn }. Nous commençons par définir la sémantique
concrète (Winskel, 1993) de P : nous considérons un programme comme une fonction
JP K : RV → RV , où σ ∈ RV est un état associant à chaque variable sa valeur réelle.
Cette fonction lie les valeurs des variables du programme avant et après son exécution. Ainsi, étant donné un état initial du programme σ0 ∈ RV , le calcul de JP K(σ0 )
décrit l’évolution des variables du programme au cours de son exécution à partir de
σ0 . Grâce à JP K(σ0 ), on peut donc vérifier l’absence d’erreurs lors de cette exécution. Dans le cas où les valeurs des variables d’entrée ne sont pas connues exactement
mais uniquement
déterminées par leur appartenance à un ensemble d’états possible
Σ0 ∈ P RV , il faut calculer la fonction JP K sur chaque état σ0 ∈ Σ0 . Pour cela,
nous définissons la fonction de sémantique collectrice JP Kc : P RV → P RV qui
calcule l’ensemble des valeurs possibles prises par les variables de P lors de toutes
les exécutions possibles. On peut donc prouver l’absence d’erreurs sur un ensemble
de valeurs initiales en calculant JP Kc (Σ0 ) et en vérifiant qu’aucune des exécutions ne
comporte de bogues. Pour des programmes de taille industrielle, ce calcul est clairement impossible pour plusieurs raisons. Premièrement, l’ensemble Σ0 contient un
nombre important d’états, donc la représentation en mémoire de Σ0 et JP Kc (Σ0 ) est
problématique. Enfin, le calcul de JP Kc (Σ0 ) nécessite le calcul d’un point fixe d’une
fonction monotone (voir (Winskel, 1993) pour plus de détails). Ce point fixe se calcule
par une itération de Kleene, qui peut ne terminer qu’après un nombre infini d’étapes.
Pour résoudre ces problèmes, la théorie de l’interprétation abstraite revient à calculer, à la place de JP Kc (Σ0 ), une propriété abstraite sur cet ensemble. Cette propriété
est encodée par un domaine abstrait, et est calculée par la fonction de sémantique
abstraite, notée JP Ka . Cette sémantique abstraite doit vérifier un critère de sûreté qui
peut s’exprimer ainsi : si l’état initial Σ0 vérifie la propriété s0 , ce que nous notons
Σ0 ⊆ γ(s0 ), alors JP Kc (Σ
0 ) doit vérifier la propriété JP Ka (s0 ), ce que nous notons
JP Kc (Σ0 ) ⊆ γ JP Ka (s0 ) . La notion de propriété est liée à la notion de domaine abstrait : un domaine abstrait définit un type de propriétés que nous pouvons prouver sur
un programme. Nous détaillons ce concept dans le paragraphe suivant. Pour propager
les propriétés, la fonction JP Ka doit aussi calculer un point fixe : il est donc nécessaire
de rendre ce calcul fini en utilisant une technique d’accélération appelée widening,
que nous détaillons ensuite.
Domaine abstrait. Un domaine abstrait Da est un treillis (Birkhoff, 1940), c’est-àdire un ensemble ordonné muni du calcul du supremum t et de l’infimum u de deux
éléments 1 . Un élément du treillis encode une propriété sur les états du programme. Par
exemple, si on considère le treillis des signes Ds = {⊥, +, −, >} et que le programme
n’a qu’une variable x, alors l’élément + représentel’ensemble des états tels que x ≥
0. On définit donc une fonction γ : Da → P RV , dite fonction de concrétisation,
qui associe à chaque propriété l’ensemble des états qui la satisfont ; cette fonction γ
1. Nous imposons une structure de treillis pour avoir ces opérateurs de supremum et infimum binaires, car
ils apparaissent dans les équations des sémantiques concrètes et abstraites dès que le programme contient
des tests ou des boucles.
342
doit être monotone. Ainsi, pour le domaine des signes et toujours pour un programme
à une variable x, on aura :
γ(⊥) = ∅;
γ(−) = {σ | σ(x) ≤ 0};
γ(+) = {σ | σ(x) ≥ 0};
γ(>) = RV .
L’ordre sur le domaine abstrait (ici, par exemple, + v >) doit être compatible
avec cette notion d’information : une propriété « plus grande » est vérifiée par un
ensemble plus grand d’états, ce qui justifie la monotonie imposée à γ. Les propriétés
encodées par un domaine abstrait ne sont généralement pas des propriétés de sûreté.
Par exemple, un domaine abstrait n’encode pas la propriété « il n’y a pas de division
par zéro », mais encode des propriétés sur les états du programme (toutes les variables
sont strictement positives) qui permettent ensuite de prouver l’absence de bogues. Si
l’analyse n’est pas assez précise, la propriété numérique trouvée ne permet pas de
conclure sur l’absence de bogues, on parle alors de fausses alarmes.
De nombreux domaines abstraits existent, notamment pour les propriétés numériques sur les variables du programme. Le domaine des intervalles (Cousot, Cousot,
1977) calcule des bornes inférieures et supérieures sur les valeurs prises par chaque
variable du programme. D’autres domaines, dits relationnels, calculent des propriétés
plus complexes faisant intervenir plusieurs variables du programme. Ainsi, le domaine
des polyèdres (Cousot, Halbwachs, 1978) permet de trouver des
Pninégalités linéaires
entre les variables du programme, i.e. des relations du type i=1 αi xi ≤ c, avec
αi ∈ R, c ∈ R et V = {x1 , . . . , xn }. Pour une description complète des différents
domaines numériques existants, nous invitons le lecteur à lire (Miné, 2004).
Calcul de la sémantique abstraite : widening. Une fois le domaine abstrait choisi, il
faut donc définir la fonction de sémantique
abstraite JP
Ka de telle sorte que, pour un
élément abstrait s, on ait JP Kc γ(s) ⊆ γ JP Ka (s) . Autrement dit, si les entrées
du programme vérifient une propriété s avant l’exécution, alors toutes les sorties du
programme doivent vérifier la propriété JP Ka (s). Notons que ceci ne signifie pas que
JP Ka (s) est la plus petite propriété vérifiée par les variables du programme : on s’autorise à sur-approximer le comportement exact du programme. Ainsi, si les propriétés
calculées JP Ka (s) suffisent à prouver que le programme est sans bogue, on pourra
conclure que les exécutions du programme P ne créent pas de ce type de bogues (par
exemple, on a prouvé que toutes les variables du programme sont supérieures à 1, il
n’y aura donc pas de division par zéro).
Pour calculer JP Ka , il faudra, comme pour JP Kc , calculer le point fixe d’une fonction monotone (opérant cette fois sur des valeurs abstraites). Le calcul de ce point
fixe par itération de Kleene peut ne pas terminer, si le domaine abstrait choisi permet
d’avoir des chaînes croissantes infinies. Pour éviter ce phénomène, l’interprétation
abstraite introduit la notion de widening (Cousot, Cousot, 1992b ; Monniaux, 2009) :
le widening transforme une chaîne croissante infinie s0 v s1 v s2 v . . . en une
chaîne croissante finie s0 = t0 v t1 v t2 v · · · v tn = tn+1 . Par exemple, dans le
domaine des intervalles, le widening détecte si la borne supérieure d’une variable x
augmente dans la suite (sn ) et dans ce cas change la borne supérieure en +∞. Ainsi,
on force bien la terminaison du calcul : à l’étape suivante, la borne supérieure de x sera
343
égale à +∞ également. Malheureusement, cette technique ne garantit plus l’obtention
de la propriété minimale, c’est-à-dire du plus petit point fixe de JP Ka : la valeur calculée tn est un post point fixe de JP Ka et est plus grande que le plus petit point fixe.
Le widening est souvent la source principale de fausses alarmes dans l’analyse statique de programmes, car la sur-approximation introduite pour garantir la terminaison
du calcul est très forte. Des travaux récents visent à limiter ce problème en proposant
de nouvelles méthodes d’accélération du calcul de point fixe (Gonnord, Halbwachs,
2006 ; Schrammel, Jeannet, 2010 ; Bouissou, Seladji, Chapoutot, 2012).
2.2. Cas des logiciels de contrôle-commande
L’analyse des logiciels de contrôle-commande par interprétation abstraite est particulièrement intéressante car ce sont souvent des logiciels critiques, c’est-à-dire dont
une défaillance serait dangereuse. Il n’existe pas de définition formelle d’un logiciel de
contrôle-commande, nous donnons ici une caractérisation du type de logiciel auquel
nous nous intéressons. Un logiciel de contrôle-commande est un programme connecté
à un environnement extérieur via des capteurs et des actionneurs et qui fonctionne
selon la boucle « Lire-Calculer-Écrire » que l’on peut schématiquement représenter
ainsi :
Initialise ;
tant que vrai faire
Lire entrées ;
Calculer état suivant ;
Écrire sorties ;
L’instruction « Lire » récupère des nouvelles valeurs provenant des capteurs (par
exemple la hauteur d’eau dans les réservoirs), l’étape « Calculer » décide de l’action
à effectuer (par exemple, ouvrir la vanne de R1 ) et l’étape « Écrire » utilise les actionneurs pour effectuer cette action (la vanne est donc effectivement ouverte). Nous
détaillons en section 3 la sémantique précise de ces programmes et les liens existant
entre ce modèle et les modèles classiques de représentation de systèmes hybrides (notamment les automates hybrides (Henzinger, 1996 ; Lygeros et al., 2003)).
Pour effectuer une analyse par interprétation abstraite d’un tel programme, il convient de sur-approximer les instructions « Lire » et « Écrire », l’étape « Calculer » pouvant être analysée comme décrit précédemment. Classiquement, un analyseur statique
va « oublier » l’étape Écrire qui ne modifie pas les valeurs des variables du programme,
et va sur-approximer l’instruction « Lire » en utilisant l’intervalle de valeurs que peut
fournir le capteur (généralement donné par la spécification du capteur). Ainsi, on calcule bien une sur-approximation de l’ensemble des valeurs prises par les variables
du programme. Cependant, on ne prend alors pas en compte la dynamique des grandeurs physiques mesurées par le capteur. Or cette dynamique est souvent prise en
compte par le programmeur de l’algorithme de contrôle et le programme est conçu
pour se comporter « normalement » si les entrées suivent cette dynamique. Pour obtenir des résultats précis, c’est-à-dire une sur-approximation la plus petite possible
344
L1
l1
Évolution de h1 au cours du temps
L2
l2
Évolution de h2 au cours du temps
Figure 2. Simulation du système des deux réservoirs en Simulink
de l’ensemble des comportements du programme, il est donc nécessaire de prendre
en compte la dynamique de l’environnement continu et les interactions entre le programme et l’environnement. Par exemple, pour le système des deux réservoirs, une
simulation réalisée en Simulink donne l’évolution de la figure 2 pour les hauteurs
d’eau dans chaque réservoir. Une analyse statique de ce système en ne regardant que
le programme (et donc en oubliant les étapes Lire et Écrire) serait incapable de démontrer que les hauteurs d’eau restent bornées : il faut savoir que si le programme
décide de fermer la vanne entre les deux réservoirs, la hauteur d’eau dans le réservoir 1 remonte. L’objectif dans (Bouissou, 2008) était d’étendre les analyses statiques
classiques pour prendre en compte les interactions entre le programme et son environnement continu. En particulier, on cherche à donner des garanties sur l’évolution
temporelle des valeurs physiques : pour tout temps t, on donne des bornes possibles
pour ces valeurs. Autrement dit, nous cherchons à calculer l’ensemble atteignable par
les grandeurs d’un système physique contrôlées par un programme discret.
Dans la section 6, nous donnons les travaux fondateurs de la théorie des systèmes
hybrides, dans laquelle s’inscrit ce travail. Cependant, il nous semble important de
mentionner maintenant la différence entre notre approche, dédiée aux logiciels embarqués de contrôle-commande, et la théorie des automates hybrides. Nous l’avons
dit, nous considérons qu’un programme de contrôle-commande fonctionne selon une
boucle Lire-Calculer-Écrire. Nous faisons de plus l’hypothèse que le programme est
synchrone, c’est-à-dire que cette boucle s’exécute à une fréquence connue et que donc
les actions Lire et Écrire ne s’exécutent qu’à des instants connus. Au contraire, l’exécution d’un automate hybride suit une boucle du type :
Initialise ;
tant que vrai faire
Attendre l’évènement E ;
Exécute la transition ;
345
L’exécution d’un système hybride est donc dirigée par les évènements alors qu’un
programme de contrôle-commande est dirigé par le temps. C’est pour cela que nous
avons décidé de développer un nouveau modèle et des techniques d’analyse ad hoc.
3. Un modèle pour les programmes de contrôle-commande
Dans cette section, nous présentons le langage de programmation H-SIMPLE
qui est une extension hybride d’un langage impératif de base. Ce langage a été pensé
pour pouvoir encoder facilement un algorithme reposant sur la boucle « Lire-CalculerÉcrire » présentée en section 1. Il est cependant assez générique et les programmes
H-SIMPLE peuvent avoir une forme différente. Lors de l’analyse cependant (voir les
sections 4 et 5), nous supposons que les programmes suivent la boucle « Lire-CalculerÉcrire ». Nous commençons par présenter la syntaxe du langage puis donnons sa sémantique. Une sémantique dénotationnelle a été définie dans l’article (Bouissou, Martel, 2008), nous en donnons ici une version opérationnelle, plus simple.
3.1. Le modèle
Nous avons développé H-SIMPLE avec trois objectifs. Premièrement, nous voulions séparer clairement les variables discrètes et les variables continues, et faire apparaître distinctement les capteurs et les actionneurs. Deuxièmement, nous voulions modéliser indépendemment le programme de contrôle et l’environnement continu. Enfin,
nous souhaitions minimiser les modifications à apporter à un programme de contrôlecommande existant. Ces trois objectifs sont nécessaires pour que ce modèle soit utilisé
pour la vérification de programmes de contrôle-commande industriels.
Notre modèle fait donc la différence entre les variables discrètes (appelées DVar)
qui sont traditionnellement encodées en utilisant des nombres à virgule flottante, et
les variables continues (appelées CVar) qui sont des nombres réels. Les variables discrètes sont manipulées par le programme, alors que l’évolution des variables continues
est régie par l’environnement continu. La communication entre ces deux types de variables se fait par l’intermédiaire de capteurs qui transforment une variable continue
en une variable discrète (avec donc une conversion vers les nombres flottants) et d’actionneurs qui modifient la dynamique des variables continues. Un actionneur ne peut
pas modifier la valeur d’une variable continue : celle-ci représente en effet une grandeur physique, son évolution doit toujours être continue. Nous n’autorisons donc que
des changements dans la dynamique de l’environnement, pas dans sa valeur. Pour effectuer ces changements, nous introduisons des variables discrètes spéciales, appelées
variables d’actions et notées AVar, qui représentent les actionneurs du système. Ces
variables sont partagées par le programme et l’environnement continu (ce sont des
paramètres de la dynamique) ; activer un actionneur revient donc à modifier la valeur
d’une de ces variables.
Il existe généralement deux types de contrôle : le contrôle binaire (ou contrôle
bang-bang) où le programme choisit de façon binaire entre deux états possibles pour
346
un actionneur, et le contrôle numérique où le programme modifie une grandeur numérique. Par exemple, les actionneurs qui servent à ouvrir et fermer les vannes du système des deux réservoirs (figure 1) effectuent du contrôle binaire : la vanne peut être
fermée ou ouverte. En revanche, un contrôleur de vitesse dans une voiture va effectuer un contrôle numérique en modifiant l’intensité de l’accélération à chaque instant.
Dans cet article, nous ne considérons que le cas du contrôle binaire, nous avons donné
dans l’article (Bouissou et al., 2009) quelques pistes pour gérer le contrôle numérique.
Dans le cas du contrôle binaire, les variables d’action seront donc encodées par une
valeur booléenne.
3.1.1. Partie discrète
Syntaxe du langage. La partie discrète de notre modèle est un programme dont la
syntaxe est donnée à la figure 3. Ce langage contient des instructions discrètes – les
affectations, les tests ainsi qu’une boucle while – plus trois instructions hybrides
(HStmt dans la figure 3) :
– sens.y?X où y ∈ CVar et X ∈ DVar. On modélise ici un capteur qui donne à
X la valeur de y à l’instant où l’instruction est exécutée ;
– act.b!c où c ∈ {0, 1} et b ∈ AVar. Cette instruction représente un actionneur :
la dynamique continue sera changée en fonction de la valeur (0 ou 1) passée à b ;
– wait u où u ∈ R+ . Cette instruction modélise la durée des autres instructions
discrètes : on suppose en effet que chaque instruction est instantanée et on ajoute
explicitement des instructions wait pour compenser le fait qu’elles ne l’étaient pas.
Modèle de la partie discrète. Un modèle de la partie discrète d’un système hybride
(voir définition 1) est un programme écrit en H-SIMPLE , plus un ensemble de variables continues représentant les valeurs physiques mesurables et un ensemble de
variables d’action représentant les actionneurs disponibles.
D ÉFINITION 1 (Modèle de la partie discrète). — Un modèle ∆ pour la partie discrète
est un triplé (CV, BV, P ) tel que :
1. CV ⊆ CVar est un ensemble de variables continues ;
2. BV ⊆ AVar est un ensemble de variables booléennes ;
3. P est un programme suivant la syntaxe H-SIMPLE n’utilisant que des variables continues de CV pour les actions sens et que des variables de BV pour les
actions act.
E XEMPLE 2 (Problème des deux réservoirs.). — La partie discrète du problème des
deux réservoirs (c’est-à-dire le contrôleur) s’encode très simplement en H-SIMPLE
(figure 4). Le contrôleur dispose de deux capteurs qui mesurent les hauteurs d’eau h1
et h2 et les transforment en variables discrètes X1 et X2 (lignes 10 et 11). Puis, si
les niveaux critiques ont été franchis, il actionne les vannes et déclenche une alarme
indiquant un problème critique dans le système. On a rajouté dans le programme de
la figure 4 deux fonctions d’anticipation (anticipate_h1 et anticipate_h2,
lignes 20 et 21) qui permettent de prédire la hauteur d’eau dans chacun des deux
f ∈F
347
X ∈ DVar
::= f | X | a + a | a − a | a × a | a/a
AExp :
a
BExp :
b ::= true | f alse | a = a | a ≤ a
Stmt :
s ::= X := a | s; s |
if b then s else s | while b do s |
hs
u ∈ R+
X ∈ DVar y ∈ CVar b ∈ AVar c ∈ {0, 1}
HStmt :
hs ::= sens.y?X | act.b!c | wait u
Figure 3. Syntaxe du langage H-SIMPLE
réservoirs deux secondes dans le futur. On ne précise pas l’implémentation de cette
fonction d’anticipation, on peut utiliser par exemple une extrapolation linéaire. En
utilisant les valeurs calculées, on peut alors contrôler plus finement les niveaux d’eau
en anticipant sur le temps de fermeture des vannes. On va donc ouvrir (ou fermer)
les vannes si la valeur prédite dépasse les seuils critiques (lignes 22 à 29). En fin de
boucle, l’instruction wait permet de simuler la durée d’exécution des instructions
précédentes (ici, 0,01 secondes). Le modèle discret pour ce système est donc ∆r =
(CV, BV, P ) avec CV = {h1 , h2 }, BV = {b1 , b2 } et P est le programme de la
figure 4.
Un des avantages du langage H-SIMPLE est qu’il réduit l’apparition d’effets Zénon dus aux actions du processus discret. L’effet Zénon est un problème bien connu de
la communauté hybride (Heymann et al., 2005 ; Zhang et al., 2001) : dans certaines
situations, un système hybride peut effectuer une infinité d’actions discrètes en un
temps fini. Ceci est impossible dans une exécution réelle, et dans une certaine mesure
impossible dans notre modèle. En effet, l’instruction wait impose que le délai soit
une valeur constante u ∈ R+ . Comme les programmes sont de tailles finies, il existe
un temps minimum τ > 0 tel que toutes les instructions wait augmentent le temps
d’au moins τ secondes. La seule possibilité d’avoir une exécution infinie est donc que
cette exécution dure 0 seconde, et il est facile via une analyse de vivacité (en utilisant
par exemple des outils comme Terminator (Cook et al., 2006b ; 2007)) de montrer que
348
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/ / Deux v a r i a b l e s c o n t i n u e s : h1 e t h2
/ / Deux v a r i a b l e s d ’ a c t i o n s : b1 e t b2
/ / V a r i a b l e s d i s c r e t e s : X1 , X2 ,
//
h1_min , h1_max ,
//
h2_min , h2_max ,
//
X1_in_2_secs ,
//
X2_in_2_secs
i n t main ( ) {
while ( t r u e ) {
s e n s . h1 ?X1 ;
s e n s . h2 ?X2 ;
i f ( X1>h1_max )
a c t . b1 ! 0 ; t h r o w ( a l a r m ) ;
i f ( X2>h2_max )
a c t . b2 ! 0 ; t h r o w ( a l a r m ) ;
i f ( X1<h1_min )
a c t . b1 ! 1 ; t h r o w ( a l a r m ) ;
i f ( X2<h2_min )
a c t . b2 ! 1 ; t h r o w ( a l a r m ) ;
X 1 _ i n _ 2 _ s e c s = a n t i c i p a t e _ h 1 ( X1 , X2 ) ;
X 2 _ i n _ 2 _ s e c s = a n t i c i p a t e _ h 2 ( X1 , X2 ) ;
i f ( X 1 _ i n _ 2 _ s e c s >h1_max )
a c t . b1 ! 0 ;
i f ( X 2 _ i n _ 2 _ s e c s >h2_max )
a c t . b2 ! 0 ;
i f ( X 1 _ i n _ 2 _ s e c s <h1_min )
a c t . b1 ! 1 ;
i f ( X 2 _ i n _ 2 _ s e c s <h2_min )
a c t . b2 ! 1 ;
wait ( 0 . 0 1 ) ;
// delai
}
}
Figure 4. Encodage du système des deux réservoirs en H-SIMPLE
toute exécution infinie contient un nombre infini d’instructions wait : dans ce cas, il
ne pourra pas y avoir d’effet Zénon.
3.1.2. Partie continue
La partie continue des systèmes hybrides que nous considérons est formée de variables évoluant continûment dans le temps et qui représentent les grandeurs physiques avec lesquelles le programme interagit. L’évolution de ces grandeurs physiques
est donnée par une équation différentielle ordinaire (EDO), c’est-à-dire une relation
349
entre une fonction y : D → Rn définie sur un ouvert D et sa dérivée temporelle
ẏ : D → Rn , donnée par :
ẏ(t) = F (y(t), t) .
(1)
Par convention, nous notons souvent l’EDO ẏ = F (y, t) et ẏ = F (y) dans le cas
dune EDO autonome.
Supposons qu’un programme dispose de m variables d’actions b1 , . . . , bm ∈ AVar.
Nous noterons ~b ∈ Bm le vecteur de booléens tel que ∀i ∈ [1, m], ~bi = bi . Alors ~b
peut prendre 2m valeurs différentes et chacune de ces valeurs représente une configuration du système. Par exemple, pour le système des deux réservoirs, on a m = 2 et il
y a 4 configurations possibles : V1 , V2 ouvertes, V1 ouverte et V2 fermée, V2 ouverte
et V1 fermée, et enfin V1 , V2 fermées. Le modèle de l’environnement continu associera donc à chaque valeur de ~b une équation différentielle représentant l’évolution
des variables continues dans cette configuration.
D ÉFINITION 3 (Modèle du milieu continu). — Un modèle κ pour le milieu continu
est un quadruplé κ = CV, BV, {Fk }k∈Bm tel que :
1. CV ⊆ CVar est un ensemble de variables continues ;
2. BV = b1 , . . . , bm ⊆ AVar est un ensemble de variables d’actions ;
3. ∀k ∈ Bm , Fk : R|CV | → R|CV | est continue et Lipschitz par morceaux.
Nous imposons que les fonctions définissant les équations différentielles soient continues et Lipschitz par morceaux pour s’assurer de l’existence et unicité de leur solution.
E XEMPLE 4 (Problème des deux réservoirs). — Le problème des deux réservoirs possède quatre modes continus correspondant aux cas où les vannes 1 et 2
sont ouvertes et/ou fermées. Un modèle continu
pour ce système sera donc κr =
{h1 , h2 }, {b1 , b2 }, {F0,0 , F1,0 , F0,1 , F1,1 } où F0,0 représente le cas où les deux
vannes sont ouvertes, F1,0 le cas où la vanne 1 est fermée, F0,1 le cas où la vanne
2 est fermée et F1,1 le cas où les deux vannes sont fermées.
3.1.3. Modèle hybride
Dans notre formalisme, un système hybride sera donc un couple (∆, κ) tel que ∆
est un modèle de la partie discrète et κ un modèle de la partie continue et tel que ∆ et
κ partagent les mêmes variables continues et les mêmes actionneurs.
D ÉFINITION 5 (Modèle du système hybride). — Un modèle Ω pour le système hybride est un couple Ω = (∆, κ) tel que :
– ∆ = CV1 , BV1 , P est un modèle de la partie discrète ;
– κ = CV2 , BV2 , {Fk }k∈B|BV2 | est un modèle de la partie continue ;
– CV1 ⊆ CV2 et BV1 ⊆ BV2 .
La dernière condition permet de s’assurer que le programme et le milieu continu sont
compatibles, c’est-à-dire que les variables sur lesquelles le programme peut agir (via
une instruction sens ou act) sont bien des variables contrôlées par le milieu continu.
350
Dans ce modèle, le programme et son environnement sont deux processus s’exécutant en parallèle et communiquant via des capteurs et des actionneurs qui servent de
canaux de communication. Ces canaux sont fixes et connus : cette communication est
donc proche du modèle proposé par les Communicating Sequential Processes (Hoare,
1985), c’est pourquoi nous utilisons la même syntaxe que les instructions CSP : le
« ? » modélise la réception de valeur, le « ! » l’envoi de message.
Remarquons que ce modèle est conforme aux une modélisation de la partie discrète
ne demande que quelques objectifs que nous nous étions fixés. En effet, ajouts aux
programmes existants, les actions des capteurs et des actionneurs sont explicites, la
communication entre les parties discrètes et continues se fait par envoi de messages et
enfin les sous-systèmes discrets et continus peuvent être modélisés séparément, dans
des formalismes différents. La figure 5 donne une vision schématique des interactions
entre le milieu continu et le programme discret dans notre modèle. La partie discrète
est un programme écrit en H-SIMPLE qui calcule, en fonction de son état interne et
des entrées provenant des capteurs, un résultat envoyé aux actionneurs. Ce résultat,
noté cmd sur la figure 5, équivaut à choisir, parmi tous les modes disponibles, celui
correspondant à l’actionneur à activer. Le milieu continu peut être vu comme une EDO
à commutateur représentée par le bloc en haut du schéma. L’entrée de ce bloc est une
commande venant des actionneurs, et la sortie est la valeur courante y de la solution
de l’EDO. Cette valeur est transmise au capteur qui la transforme en le nombre flottant
le plus proche, c’est-à-dire y.
3.2. Sémantique opérationnelle du modèle
L’exécution d’un système hybride (∆, κ) est une succession de transitions discrètes, instantanées, modifiant les variables discrètes du programme, et des transitions
continues, modifiant la valeur des variables de l’environnement continu. L’état d’un
système hybride (voir définition 6) est donc caractérisé par la valeur de chaque variable discrète, de chaque variable continu, des variables d’action ainsi que du temps.
Nous définissons un état discret comme une fonction associant à une variable discrète un nombre à virgule flottante, et notons Σd l’ensemble des états discrets : Σd =
DVar → F. De même, un état continu associe à chaque variable continue une valeur
réelle et Σc = CVar → R est l’ensemble des états continus. Enfin, la configuration des
actionneurs est donnée par une fonction associant à chaque variable d’action une valeur booléenne. Nous notons Σb = AVar → B l’ensemble de ces configurations. Pour
chaque état σ et variable v, nous notons σ(v) la valeur de v dans l’état σ et σ[v 7→ r]
l’état σ 0 tel que σ 0 (v) = r et pour toute autre variable v 0 , σ 0 (v 0 ) = σ(v 0 ). Étant donné
un état continu σc ∈ Σc , nous notons σc (~y ) ∈ R|CVar| le vecteur contenant toutes les
valeurs associées aux variables continues.
D ÉFINITION 6 (État d’un système hybride). — Soit Ω = (∆, κ) un système hybride.
L’état du système est un quadruplé σ = (σd , σc , σb , t) tel que σd ∈ Σd , σc ∈ Σc ,
σb ∈ Σb et t ∈ R+ représente le temps.
351
y
F1
ẏ
y
1
s
F2
···
Fn
Modèle continu
cmd
Capteurs
Actionneurs
y
État
interne
Programme discret
Figure 5. Fonctionnement d’un programme embarqué
Les états discrets ainsi que les configurations des actionneurs seront modifiées par
le programme via un système de transition classique, que nous définissons dans la
suite. Par contre, l’état continu est modifié par les équations différentielles qui définissent la dynamique du milieu continu. Soit une EDO de dimension n, ẏ = F (y),
où la fonction F : R|CVar| → R|CVar| est continue et Lipschitz par morceaux, et soit
σc ∈ Σc un état continu donnant la valeur des variables ~y . La fonction d’avancement
du temps (souvent appelée time elapse dans la littérature de systèmes hybrides) est la
fonction %F : Σc × R+ → Σc définie par :
∀σc ∈ Σc , ∀t ∈ R+ , %F (σc , t) = y∞ (t)
où y∞ est l’unique solution du problème de Cauchy ẏ = F (y), y(0) = σc (~y ) 2 .
Nous définissons maintenant la sémantique opérationnelle de ces systèmes hybrides comme un système de transition κ ` hstmt, σi → hstmt0 , σ 0 i, qui signifie
que sous l’effet de l’environnement κ, l’instruction stmt est exécutée dans l’état σ
et se transforme en l’instruction stmt0 dans l’état σ 0 . La figure 6 donne les règles
de la sémantique opérationnelle. Nous ne donnons pas les règles pour les instructions discrètes (Stmt à la figure 3) car ce sont les mêmes que pour n’importe quel
2. Nous utilisons ici implicitement l’isomorphisme entre Σc = CVar → R et R|CVar| et considérons
y∞ (t) ∈ R|CVar| comme un élément de Σc .
352
σ 0 = σd [X 7→↑◦ σc (y) ]
C APTEUR
κ ` hsens.y?X; stmt, (σd , σc , σb , t)i → hstmt, (σ 0 , σc , σb , t)i
σb0 = σb [bi 7→ b]
ACTIONNEUR
κ ` hact.bi !b; stmt, (σd , σc , σb , t)i → hstmt, (σd , σc , σb0 , t)i
κ = V, B, {Fk } , (y0 , k0 )
~b = (σb (b1 ), . . . , σb (bn ))
σc0 =%F~b (σc , u)
u
κ ` hwait u; stmt, (σd , σc , σb , t)i −
→ hstmt, (σd , σc0 , σb , t + u)i
D ÉLAI
hstmt, σd i →d hstmt0 , σd0 i
D ISCRET
κ ` hstmt, (σd , σc , σb , t)i → hstmt0 , (σd0 , σc , σb , r)i
Figure 6. Règles d’inférence de la sémantique opérationnelle de H-SIMPLE
langage impératif. Nous supposons disposer d’une règle de transition hstmt, σd i →d
hstmt0 , σd0 i qui modifie un état discret par une instruction discrète (voir par exemple
le livre (Winskel, 1993) pour une définition de la transition →d ). Nous ajoutons trois
règles qui correspondent aux trois instructions hybrides. Les règles C APTEUR et AC TIONNEUR sont très simples : elles mettent à jour l’état discret et la configuration
des actionneurs, respectivement. Dans la règle C APTEUR, la valeur réelle σc (y) est
transformée en une valeur flottante par la fonction de conversion ↑◦ : cette fonction
est fournie par la norme IEEE-754 de l’arithmétique flottante. La règle D ÉLAI correspondant à l’instruction wait u est plus compliquée : elle fait avancer le temps tout en
modifiant l’état continu pour que celui-ci contienne à tout instant la solution de l’équation différentielle choisie par l’état des actionneurs. Il faut donc d’abord sélectionner
l’équation différentielle représentant une configuration des actionneurs : on construit
le vecteur de booléens ~b = (σb (b1 ), . . . , σb (bm )), les variables continues évoluent
donc selon l’équation différentielle F~b . On applique alors la fonction d’avancement
dans le temps pour calculer le nouvel état continu.
Les règles de la figure 6 permettent de définir une sémantique opérationnelle à
petit pas de H-SIMPLE, notons que nous distinguons la transition induite par la règle
u
D ÉLAI des autres transitions en la notant −
→. C’est la seule transition qui n’est pas
instantanée (elle modifie le temps dans l’état du système hybride) et sera importante
ultérieurement. Dans la suite, le modèle continu utilisé sera implicite : nous notons
hstmt, σi → hstmt0 , σ 0 i pour κ ` hstmt, σi → hstmt0 , σ 0 i .
Notons ⇒ la clôture de la transition →: pour tout σ, σ 0 ∈ Σ, on a hstmt, σi ⇒
hstmt0 , σ 0 i si et seulement si il existe une suite d’états σ1 , . . . , σn et d’instructions
stmt1 , . . . , stmtn telle que :
hstmt, σi → hstmt1 , σ1 i → hstmt2 , σ2 i · · · → hstmtn , σn i → hstmt0 , σ 0 i
353
Une exécution d’un programme P dans un environnement continu κ est une suite de
u
transitions « à grand pas » ⇒ et de transitions continues −
→. Formellement, l’exécution
de P à partir d’un état initial σ0 est une suite d’états et d’instructions telle que :
u
u
1
2
hP, σ0 i ⇒ hstmt00 , σ00 i −→
hstmt1 , σ1 i ⇒ hstmt01 , σ10 i −→
hstmt2 , σ2 i ⇒ . . .
Notons qu’il existe une différence majeure entre la transition ⇒ qui ne modifie ni
u
le temps ni les variables continues et la transition −
→ qui ne modifie pas les variables
discrètes. Ceci est formalisé dans la proposition 7.
u
u
2
1
σ2 ⇒ . . . d’un
σ1 ⇒ σ10 −→
P ROPOSITION 7. — Soit une exécution σ0 ⇒ σ00 −→
programme P . Alors, pour tout i ∈ N, on a :
– σi (t) = σi0 (t) et σi (~y ) = σi0 (~y )
– ∀v ∈ DVar ∪ AVar, σi0 (v) = σi+1 (v).
4. Génération d’invariants pour une classe de programmes
de contrôle-commande
Nous essayons maintenant de définir une méthode d’analyse des systèmes hybrides
présentés en section 3. Notre but n’est pas de prouver l’absence d’erreurs à l’exécution
sur le programme mais de prouver des propriétés concernant l’évolution temporelle de
l’environnement continu interagissant avec le programme : une propriété intéressante,
par exemple, est de montrer qu’une région de l’espace n’est pas atteignable. Pour prouver ce type de propriétés, il faut vérifier que dans toutes les exécutions possibles du
système hybride, l’état continu ne rentre jamais dans la région interdite. En raison d’incertitudes portant sur l’état initial du programme, l’ensemble de toutes les exécutions
n’est pas calculable : nous calculerons donc une sur-approximation des trajectoires
continues. Notre analyse cherche ainsi à calculer des invariants sur les trajectoires de
l’environnement continu d’un système hybride. Dans la section 4.2, nous définissons
formellement la notion d’invariants pour la trajectoire temporelle, puis définissons en
section 4.4 un algorithme permettant d’abstraire le programme en un ensemble de
graphes, appelé k-tree 3 , permettant de calculer ces invariants. L’algorithme de calcul des invariants à proprement parler est décrit dans la section 5. La méthode que
nous présentons ici est conçue pour fonctionner sur une certaine classe de systèmes
de contrôle-commande. Nous commençons par définir cette classe en section 4.1 et
discutons de sa généralité.
Notations. Dans cette section, nous notons IR le treillis des intervalles fermées sur R.
Un état continu abstrait sera donc une fonction des variables continues CVar vers IR ,
et nous noterons Σc l’ensemble des états continus abstraits. Pour tout σc ∈ Σc , nous
noterons σc (~y ) ∈ IR n l’hyper-rectangle contenant les valeurs abstraites de chaque
variable. Pour tout état concret σc ∈ Σc , nous noterons σc ∈ σc si pour toute variable
3. Le terme k-tree est une généralisation des quadtree (Finkel, Bentley, 1974), structure de données très
employée pour la représentation d’images.
354
continue v ∈ CVar, σc (v) ∈ σc (v). De même, B⊥ représentera le treillis complet des
valeurs booléennes, B⊥ = {⊥, 0, 1, >} est muni de l’ordre v défini par :
⊥ v 0, ⊥ v 1, 0 v >, 1 v > .
L’élément 0 représente la valeur « faux », 1 représente la valeur « vrai ». Nous définissons alors les configurations abstraites pour les actionneurs par les fonctions des
variables d’action AVar dans B⊥ : Σb = AVar → B⊥ . Par abus de notation, nous noterons σb ∈ σb pour signaler qu’une configuration σb ∈ Σb est dans la concrétisation
de la configuration abstraite σb ∈ Σb .
4.1. Hypothèses simplificatrices
Nous supposons disposer de programmes de contrôle-commande qui suivent la
boucle « Lire-Calculer-Écrire » décrite dans la section 2.2. Autrement dit, les systèmes
hybrides que nous considérons sont donnés par (∆, κ) tels que ∆ = (P, CV, AV ), et
P est un programme écrit en H-SIMPLE et qui vérifie les hypothèses suivantes 4 .
H1 : Capteurs et actionneurs parfaits. Nous supposons que les capteurs et les actionneurs fonctionnent tous à la même fréquence, et qu’il n’y a pas de bruit de lecture
sur les capteurs ni d’écriture sur les actionneurs.
H2 : Structure du programme. Nous supposons que P peut s’écrire comme P =
while 1 do{Pl ; Pc ; Pe ; wait h}, où Pl est une succession d’instructions sens, Pe
est une succession de tests if et d’instructions act , et Pc ne contient pas d’instructions hybrides. Nous faisons donc l’hypothèse que tous les capteurs mesurent simultanément une valeur et que tous les actionneurs écrivent simultanément leur contenu.
Ces actions sont instantanées, et l’instruction wait en fin de boucle permet de faire
avancer le temps : nous faisons donc l’hypothèse d’un fonctionnement synchrone du
programme. Notons que nous pourrions relâcher un peu cette hypothèse en supposant
que P s’écrit P = while 1 do{ Pl ; wait u1 ; Pc ; wait u2 ; Pe ; wait u3 }. Cela ne
modifierait pas fondamentalement notre méthode, il faudrait juste modifier la définition de la fonction φ dans la section 4.4.
Étant donné ces deux hypothèses, l’exécution du programme P est alors une suite
h
h
d’états σ0 ⇒ σ00 −
→ σ1 ⇒ σ10 −
→ . . . où la transition ⇒ représente l’exécution de
h
Pl , Pc et Pe et −
→ est l’exécution de l’instruction wait. Notons JP K : Σ → Σ la
fonction telle que pour tout état σ ∈ Σ, σ ⇒ JP K(σ). Cette fonction ne modifie pas
l’état continu du système car il n’y a pas d’instructions wait dans Pl , Pc et Pe , on a
donc, si σ = (σd , σc , σb , t), JP K(σ) = (σd0 , σc , σb0 , t) avec σd0 ∈ Σd et σb0 ∈ Σb . La
dernière hypothèse que nous faisons porte sur cette fonction JP K.
H3 : Programmes invariants dans le temps. Nous supposerons que l’algorithme
de contrôle-commande ne dépend que des dernières valeurs lues par les capteurs : la
4. Nous n’imposons pas d’hypothèses sur l’environnement continu κ autre que celle donnée en section 3.1.2, à savoir que les équations différentielles sont continues et Lipschitz par morceaux.
355
fonction JP K ne doit pas dépendre d’une mémoire interne. Ainsi, pour tout σd1 , σd2 ∈
Σd et t1 , t2 ∈ R, on a : ∀σc ∈ Σc , σb ∈ Σb ,
0
0
si JP K(σd1 , σc , σb , t1 ) = (σd1 , σc , σb0 , t1 ), alors JP K(σd2 , σc , σb , t2 ) = (σd2 , σc , σb0 , t2 ).
Autrement dit, si le programme lit deux fois les mêmes valeurs continues sur ses
capteurs, alors il activera les mêmes actionneurs à chaque fois, quelles que soient les
valeurs des variables discrètes avant la lecture par les capteurs. Nous dirons d’un tel
programme qu’il est invariant dans le temps.
Ces hypothèses sont relativement restrictives mais permettent une analyse efficace
et précise des programmes les vérifiant. L’hypothèse H1 est très souvent faite pour
l’analyse de systèmes hybrides, le bruit de mesure ou les erreurs d’écriture sur les actionneurs étant la plupart du temps négligés. Nous pensons pouvoir ajouter à l’analyse
actuelle de l’information quant à ce bruit : les techniques présentées ici parlent du
comportement idéal du système, les déviations à ce comportement peuvent être introduites grâce à des techniques proches de celles utilisées pour l’analyse de la précision
des calculs en nombres à virgule flottante (Putot et al., 2003 ; Goubault, Putot, 2006).
L’hypothèse H2 est elle souvent vérifiée par les programmes de contrôle-commande
embarqués critiques, qui sont généralement générés à partir d’un modèle synchrone
(développé en SCADE par exemple) et qui suivent donc la boucle « Lire-CalculerÉcrire ». Enfin, l’hypothèse H3 est la plus restrictive car elle interdit des programmes
qui commencent par filtrer les données lues sur les capteurs avant de les traiter. Ces
filtres utilisent souvent les n dernières valeurs lues pour lisser le signal. Nous pensons
que notre technique peut être étendue pour traiter le cas où l’activation d’un actionneur dépend des n dernières valeurs lues, avec n fini. Nous discutons cela dans la
conclusion.
E XEMPLE 8. — Le programme
P ::= while 1 do(sens.y?X; if y > 1 then act.b0 !0; else act.b0 !1; )
est invariant dans le temps. En revanche, le programme
P 0 ::= while 1 do(sens.y?X; z = z + y; if z > 1 then act.0!0; else act.0!1; )
ne l’est pas car l’exécution d’un actionneur dépend de toutes les valeurs reçues depuis
le début du programme.
4.2. Trajectoire continue, invariants de trajectoire
Soit Ω un système hybride vérifiant les hypothèses H1, H2 et H3, et soit h le délai
h
imposé par l’instruction wait entre deux tours de la boucle. Soit σ0 ⇒ σ00 −
→ σ1 ⇒
h
→ . . . les états du système lors d’une exécution (tels que définis à la section 3).
σ10 −
D’après les hypothèses H1 et H2, nous avons ∀i ∈ N, σi0 (t) = σi (t) ∧ σi+1 (t) =
σi0 (t) + h. On a donc notamment σi (t) = i · h.
356
D ÉFINITION 9 (Trajectoire continue.). — La trajectoire continue de Ω le long de cette
exécution est la suite (σci , σbi ) telle que σci ∈ Σc et σbi ∈ Σb , et σi = (σdi , σci , σbi , i · h).
Autrement dit, une trajectoire continue est la projection sur Σc × Σb d’une exécution
du système hybride.
Du point de vue de l’environnement continu, la seule action que prend le programme est de changer la configuration σb des actionneurs en fonction des valeurs des
variables continues (via la lecture par les capteurs). Nous définissons donc la fonction
LP M : Σc × Σb → Σb qui, étant donné une valeur pour les variables continues calcule
la nouvelle configuration des actionneurs après exécution de la transition ⇒. D’après
l’hypothèse H3, la fonction LP M peut être définie comme
LP M(σc , σb ) = σb0 ⇔ JP K(σd0 , σc , σb , 0) = (σd0 , σc , σb0 , 0),
où σd0 associe à chaque variable discrète la valeur 0. En effet, l’hypothèse H3 stipule
que le résultat de JP K(σd , σc , σb , t) est le même quel que soit σd ∈ Σd et t ∈ R. Nous
choisissons donc t = 0 et σd = σ0 pour calculer JP K(σd , σc , σb , t).
La définition d’une trajectoire continue est simplifiée grâce à la fonction LP M. On
a en effet :

∀i ∈ N,
σ i+1 = LP M(σci , σbi )
b
σci+1 =%F i+1 (σci , h)
σ
b
Malheureusement, la fonction LP M n’est souvent pas calculable, donc la trajectoire
continue d’un système hybride n’est pas calculable. En suivant la méthodologie de
l’interprétation abstraite, nous allons calculer une trajectoire abstraite, que nous appellerons invariant de trajectoire.
D ÉFINITION 10 (Invariant de trajectoire). — Soit Ω un système hybride. Nous dirons
N
qu’une suite d’états abstraits (σc n , σb n ) ∈ Σc × Σd est un invariant de trajectoire de Ω si et seulement si, pour toute trajectoire continue (σcn , σbn ) de Ω on a :
∀i ∈ N, σci ∈ σc i et σbi ∈ σb i .
Clairement, un invariant étant une suite infinie d’états continus abstraits, nous chercherons en priorité à calculer des invariants sous la forme de suite périodique pour en
avoir une représentation finie.
Le calcul d’une trajectoire abstraite suit le calcul des trajectoires concrètes : nous
allons définir des fonctions LP Ma et %]F qui seront des abstractions (au sens de l’interprétation abstraite, voir section 2.1) des fonction LP M et %F . On aura alors :
(
∀i ∈ N,
σb i+1 = LP Ma (σc i , σb i )
σc i+1 =%]F i+1 (σc i , h)
σb
Dans la suite de cette section, nous expliquons comment définir la fonction LP Ma ,
puis à la section 5 nous décrivons comment définir %]F et comment calculer (σc i , σb i )
pour tout i ∈ N. Intuitivement, la fonction LP M va modifier la configuration d’un actionneur en fonction des valeurs lues par les capteurs : à chaque instant, l’actionneur bi
357
sera modifié si une instruction act.bi !c est exécutée par le programme. Nous pouvons
donc voir LP M comme une fonction booléenne qui décide, pour chaque instruction de
type act, si elle va être exécutée. La construction de la fonction abstraite LP Ma vient
de cette constatation.
4.3. Abstraction des fonctions booléennes
Dans cette section, nous définissons un algorithme d’abstraction des fonctions
réelles à valeur dans B = {0, 1} par une représentation sous forme de k-tree. Soit
donc φ : D → B une fonction booléenne 5 définie sur un hyper-rectangle D ∈ IR n .
Nous définissons d’abord notre notion d’abstraction de φ sous forme d’un k-tree puis
nous donnons l’algorithme permettant de calculer ce k-tree.
4.3.1. Représentation d’une fonction booléenne
Nous allons abstraire une fonction booléenne par sa représentation spatiale, c’està-dire un recouvrement de son domaine de définition en un ensemble de rectangles tel
que la fonction est constante sur chaque rectangle. Rappelons
qu’un recouvrement
d’un hyper-rectangle b ∈ IR n est un ensemble I(b) = b1 , . . . , bm d’éléments
de IR n tels que b = ∪m
i=1 bi . Nous représenterons les recouvrements sous la forme
d’arbres réguliers appelés k-tree.
D ÉFINITION 11 (k-trees). — Un k-tree de dimension n est un graphe dirigé, acyclique, ayant une racine unique et deux types de nœuds :
– les nœuds non terminaux de la forme N (b), avec b ∈ IR n ;
– les nœud terminaux de la forme V (v) avec v ∈ {0, 1, >};
et tel que pour tout b ∈ IR n , le nœud N (b) a soit un nœud fils de la forme V (v) soit m
nœuds fils non terminaux N1 (b1 ), N2 (b2 ), . . . , Nm (bm ) tels que {bi : i ∈ [1, m]}
est un recouvrement de b. La racine d’un k-tree T doit être un nœud non terminal, et
on dira que T est de domaine b, noté dom(T ) = b, si son nœud racine est N (b).
E XEMPLE 12. — La figure 7 montre un k-tree de dimension 2 et de profondeur 3. Les
nœuds N (resp. V ) sont représentés par des rectangles (resp. cercles).
Intuitivement, un k-tree T est la représentation de toutes les fonctions booléennes
f telles que, si T possède un nœud N (b) avec un seul nœud fils V (v), alors f vérifie
f (x) v v pour tout x ∈ b. L’ordre v est ici l’ordre sur le treillis abstrait B⊥ : si
v ∈ {0, 1}, on devra alors avoir f (x) = v, et si v = top, alors la valeur de f (x)
est inconnue. Pour tout k-tree T de domaine D ∈ IR n , et pour tout x ∈ D, on
note V (x) = v | ∃N (b0 ) ∈ T, x ∈ b0 et N (b0 ) a un seul fils V (v) l’ensemble des
5. Notons que nous n’imposons aucune hypothèse de régularité à φ pour que cette abstraction existe. Dans
la suite, φ sera la sémantique d’un programme qui est clairement non continue en présence de tests par
exemple.
358
[0, 10] × [0, 10]
[0, 5] × [0, 5]
[0, 5] × [5, 10]
1
0
[5, 10] × [0, 5]
[5, 10] × [5, 10]
0
[5, 7.5] × [0, 2.5]
[5, 7.5] × [2.5, 5] [7.5, 10] × [0, 2.5]
�
0
1
[7.5, 10] × [2.5, 5]
�
Figure 7. Exemple d’un k-tree de dimension 2 et de profondeur 3
F
feuilles de T dont le domaine contient x. On note aussi T (x) = v∈V (x) v la valeur
associée à x dans le k-tree T .
Ainsi, si T est le k-tree de la figure 7, on a : T (3, 1.5) = 1 et T (6, 1.2) = >.
D ÉFINITION 13 (Représentation d’une fonction booléenne). — Soit D ∈ IR n et
f : D → B une fonction booléenne. On dira qu’un k-tree T de dimension n est une
représentation de f si et seulement si ∀x ∈ D, f (x) v T (x).
Clairement, il n’existe pas une unique représentation pour un fonction booléenne
n
f . En particulier, si
on note dom(f ) ⊆ R le domaine de définition de f , alors le
k-tree N dom(f ) − V (>), i.e. le k-tree avec un nœud racine et un nœud terminal
valant >, est toujours une représentation de f . Pour distinguer deux représentations
différentes d’une même fonction f , nous introduisons une relation de pré-ordre sur
l’ensemble des k-trees qui est compatible avec la notion naturelle de précision de
la représentation : on dira qu’une représentation est plus précise qu’une autre si elle
renvoie moins souvent la valeur >.
D ÉFINITION 14 (Précision de la représentation : préordre sur les graphes). — Soit T
et T 0 deux k-trees avec dom(T ) = dom(T 0 ) = D. On dira que T 0 est plus précis que
T si et seulement si ∀x ∈ D, T (x0 ) v T (x). On notera alors T 0 T . La relation est un pré-ordre sur l’ensemble des k-trees de même domaine.
E XEMPLE 15. — Le k-tree de la figure 7 est plus précis que le k-tree suivant :
[0, 10] × [0, 10]
[0, 5] × [0, 5]
[0, 5] × [5, 10]
[5, 10] × [0, 5]
[5, 10] × [5, 10]
1
�
�
0
R EMARQUE 16. — Le pré-ordre n’est pas un ordre partiel car nous n’avons pas
défini de forme normale sur les k-trees. Cette forme normale est facile à définir :
359
entre deux k-trees T et T 0 vérifiant T T 0 et T 0 T , il suffit par exemple de
prendre celui de profondeur minimale. Le pré-ordre devient alors un ordre partiel.
Nous ne détaillons pas le mécanisme de normalisation des k-tree, mais dans notre
implémentation, nous calculons toujours les formes normales.
4.3.2. Algorithme d’abstraction d’une fonction booléenne
Nous montrons maintenant comment on peut construire un k-tree qui soit une
représentation d’une fonction booléenne φ : D → B, avec D ∈ IR n . Pour cela,
nous utiliserons la fonction d’inclusion, ou fonction abstraite, pour φ, c’est-à-dire une
fonction [φ] : IR n → B⊥ telle que :
∀b ∈ IR n , α {φ(x) : x ∈ b} v [φ](b)
(2)
où α : P(B) :→ B⊥ est l’abstraction classique des ensembles de valeurs booléennes
vers le treillis abstrait B⊥ et v est l’ordre partiel sur B⊥ .
E XEMPLE 17. — Soit φ : R2 → B la fonction définie par : ∀x, y ∈ R2 , φ(x, y) = 1
si x = y, φ(x, y) = 0 sinon. La fonction [φ] : IR 2 → B⊥ définie par [φ]([x] , [y]) = 0
si [x] ∩ [y] = ∅ et φ([x] , [y]) = > sinon, est une fonction d’inclusion pour φ.
Nous n’expliquons pas comment obtenir cette fonction d’inclusion pour toute fonction
φ : Rn → B. Intuitivement, les calculs numériques effectués dans φ seront traduits en
leurs équivalents sur le domaine des intervalles, et les tests seront sur-approximés. À
l’aide d’une fonction d’inclusion [φ] pour une fonction φ : D → B avec D ⊆ Rn , on
peut construire un k-tree représentant φ.
D ÉFINITION 18 (Calcul de la représentation d’une fonction booléenne). — Soit
n ∈ N et D ∈ IR n un domaine borné. Soit une fonction φ : D → B et soit
[φ] : IR n → B⊥ une fonction d’inclusion pour φ. Soit Nmax ∈ N une profondeur
maximale. On définit alors Tφ le k-tree de profondeur maximale Nmax représentant
φ par : Tφ = ConstruireKtree([φ], D, 0, Nmax ), où ConstruireKtree est
la fonction donnée par l’algorithme 1.
Remarquons que la fonction ConstruireKtree est décroissante en Nmax : plus
Nmax est élevé, plus le k-tree construit est précis.
P ROPOSITION 19. — Soit D ⊆ Rn et φ : D → B une fonction booléenne. Si [φ] est une fonction d’inclusion pour φ, alors pour tout Nmax ∈ N,
T =ConstruireKtree([φ],D,1,Nmax ) est une représentation de φ, c’est-àdire que pour tout x ∈ D, on a φ(x) v T (x).
4.4. Application à l’abstraction des transitions discrètes
Nous expliquons maintenant comment on peut utiliser l’algorithme de la section
4.3.2 pour obtenir une abstraction de la fonction LP M, étape préliminaire au calcul d’invariant sur les trajectoires. Intuitivement, pour chaque instruction du type act.bi !b,
nous allons générer un k-tree qui sera une représentation de la fonction renvoyant 1 si
360
Algorithme 1: ConstruireKtree
Entrées : [φ] : IR n → B⊥ ;
Fonction à abstraire
Entrées : D ⊆ IR n ;
Domaine de définition
Entrées : N ∈ N;
Précision actuelle
Entrées : Nmax ∈ N;
Précision maximale
Sorties : T de domaine D et de hauteur maximale Nmax − N telle que
∀x ∈ D, φ(x) v T (x)
début
x = [φ](D);
si x = > ∧ N < Nmax alors
Construite un recouvrement list de D;
res = N (D);
pour tous les élément l ∈ list faire
aux = ConstruireKtree([φ], l, N + 1, Nmax );
res = N (D) :: aux;
sinon
res = N (D) :: V (x);
retourner res
l’instruction est exécutée et 0 sinon. On pourra alors facilement construire l’abstraction de LP M : étant donné un état continu, on teste pour chaque instruction act.bi !b
si elle sera exécutée (grâce au k-tree correspondant), puis on met à jour la configuration des actionneurs en fonction de chacun de ces résultats. Le point important de
cette méthode est donc la construction d’une fonction d’inclusion booléenne qui teste
l’accessibilité d’une instruction en fonction des entrées continues du programme.
La fonction de test d’accessibilité est définie ainsi : étant donné un programme P
et une instruction à atteindre, on construit dans un premier temps le graphe de flot
de contrôle du programme puis on effectue une analyse statique par interprétation
abstraite en avant des états accessibles. Les instructions arithmétiques sont évaluées
en utilisant l’arithmétique d’intervalle, et les tests sont sur-approximés. Nous ne détaillons pas d’avantage le principe de l’analyse d’accessibilité, pour plus de détails sur
ce sujet très classique, on pourra lire (Cousot, Cousot, 1977 ; 1994).
D ÉFINITION 20 (Abstraction de la fonction LP M). — Soit Ω un système hybride
dont le programme est P . Pour tout instructions act.bi !b de P , on note Ti,b le k-tree
construit tel que décrit précédemment et qui décide de l’atteignabilité de l’instruction
act.bi !b. Alors, la fonction LP Ma : Σc × Σb → Σb définie par :
(
LP Ma (σc , σb ) = λbi .
est l’abstraction de LP M.
σb (bi )
Ti,b (σc (y))
si Ti,b (σc (y)) = 0
sinon
361
Figure 8. k-tree obtenu pour la ligne 17 du programme de la figure 4
P ROPOSITION 21. — La fonction LP Ma est une abstraction correcte de la fonction
LP M :
∀σc ∈ Σc , σb ∈ Σb , ∀σc ∈ σc , σb ∈ σb , LP M(σc , σb ) ∈ LP Ma (σc , σb ) .
Dans cette section, nous avons donc construit à partir d’un programme H-SIMPLE
une fonction LP Ma qui est une abstraction correcte de l’effet du programme sur les actionneurs. Cette fonction peut être vue comme une reconstruction, à partir de P , de la
structure de contrôle de l’algorithme de contrôle-commande : elle décide quelle action
doit être effectuée en fonction de la position spatiale de l’environnement continu. La
technique de génération des k-trees a été implémentée dans un analyseur statique qui
utilise Newspeak (Hymans, Levillain, 2008). Nous montrons dans (Bouissou, 2008)
plusieurs exemples de k-trees obtenus pour différents programmes de contrôle. La
figure 8 montre le k-tree obtenu pour l’instruction de la ligne 17 du programme de
contrôle du système des deux réservoirs donné à la figure 4. La zone grise représente
la zone telle que le k-tree renvoie 1 (l’instruction est atteinte), la zone noire celle où le
k-tree renvoie > (l’instruction peut-être atteinte) et la zone blanche celle où le k-tree
renvoie 0 (l’instruction n’est pas atteinte).
Remarquons que l’analyse d’accessibilité d’instructions de programmes impératifs
est un sujet classique, que l’on peut traiter via les travaux portant sur la terminaison de
programmes et les preuves de propriétés de sûreté (Cook et al., 2006a ; 2007 ; Cousot, 2005), ou encore l’analyse de code mort (Chen et al., 1997), souvent très utilisée
362
en compilation. Cependant, toutes ces analyses fournissent une sur-approximation de
l’ensemble des instructions exécutées. Pour que l’abstraction de l’évolution continue
soit précise, il faut que nous obtenions également une sous-approximation des instructions accessibles, c’est-à-dire l’ensemble des instructions qui seront exécutées pour
toutes les entrées du domaine. Dans l’idéal, la différence entre la sur-approximation
et la sous-approximation doit être la plus faible possible. Nous avons donc préféré
développer un nouvel outil permettant de calculer à la fois la sur-approximation et la
sous-approximation de telle sorte que l’écart entre les deux soit un des paramètres de
l’analyse.
5. Génération de trajectoire abstraite
Dans cette section, nous expliquons comment, à partir des k-tree produits par l’algorithme de la section 4, nous construisons des invariants de trajectoire pour un système hybride. Nous avons vu (définition 20) que ces k-trees servent à définir une
abstraction de la fonction LP M. Nous expliquons dans un premier temps (section 5.1)
comment la théorie de l’intégration garantie fournit des abstractions de la fonction
%F . Puis (section 5.2), nous montrons comment calculer les invariants de trajectoire,
en recherchant des motifs périodiques dans ces trajectoires.
5.1. Abstraction de la fonction d’avancement du temps
Rappelons la définition de la fonction d’avancement du temps %F :
%F :
Σc × R+
(σc , h)
→
7→
Σc
.
y∞ (h) où y∞ est la solution de l’EDO ẏ = F (y), y(0) = σc (~
y)
Une abstraction de %F doit donc être une fonction [F ] : Σc × R+ → Σc telle que :
∀σc ∈ Σc , ∀σc ∈ σc , y∞ (h) ∈ [F ](σc , h) .
(3)
Autrement dit, [F ](σ, h) doit contenir toutes les solutions en h de l’EDO ẏ =
F (y) avec une valeur initiale σc (~y ) ∈ σc (~y ). La théorie de l’intégration garantie
d’équations différentielles (Nedialkov et al., 1999) nous montre qu’il est possible de
calculer automatiquement ces sur-approximations des solutions d’EDO. En particulier, la librairie GRKLib (Bouissou, Martel, 2007) fournit un moyen automatique de
calculer une fonction [F ] monotone vérifiant les conditions de l’équation (3). Remarquons que cette construction ne suppose pas que la fonction F soit linéaire ou linéaire
par morceaux : il suffit que F soit continue et suffisamment dérivable. Nous ne détaillons pas plus la théorie de l’intégration garantie, il nous suffit dans cet article de
savoir que la construction de la fonction [F ] est possible. Pour plus de détails, nous
conseillons la lecture des articles (Nedialkov et al., 1999) et (Nedialkov, 2006).
363
5.2. Calcul d’invariants : à la recherche de boucle
Munis des fonctions abstraites JP Ka et [F ], abstractions respectives de JP K et %F ,
nous pouvons désormais facilement calculer un invariant de trajectoire pour un système hybride. Rappelons qu’un invariant de trajectoire est une suite d’éléments absN
traits (σc n , σb n ) ∈ Σc × Σb vérifiant, pour toute trajectoire continue (σcn , σbn ),
∀i ∈ N, σci ∈ σc i et σbi ∈ σb i .
Clairement, si σc 0 et σb 0 sont des abstractions de l’ensemble des états initiaux du
système, alors la suite (σc n , σb n ) définie par :
σb i+1
σc i+1
=
=
i
i
LP
S Ma (σc , σbi )
[Fσb ](σc , h) | σb ∈ (σc i+1 )
est un invariant de trajectoire. En effet, pour calculer la nouvelle configuration des actionneurs σb i+1 , on applique l’abstraction LP Ma de LP M, puis pour calculer σc i+1 , on
suit toutes les dynamiques possibles, c’est-à-dire toutes les dynamiques caractérisées
par une configuration σb ∈ σb i+1 . Enfin, on fait l’union de toutes ces dynamiques
pour obtenir σc i+1 . D’après les propriétés du sûreté des fonctions LP Ma et [F ], on
a bien, pour toute trajectoire continue (σci , σbi ) du système : ∀i ∈ N, σbi ∈ σb i et
σci ∈ σc i . On peut donc se servir de la suite (σc i ) pour tester (par exemple) si une
région interdite est atteinte. Cependant, cette suite n’est pas suffisante pour montrer
qu’une région interdite n’est jamais atteinte : comme l’élément σc i donne la position
de l’environnement continu à l’instant i × h, il faudrait calculer l’ensemble (infini) des
éléments de la suite pour prouver que la région n’est jamais atteinte. Les techniques
classiques d’analyse de systèmes hybrides se contentent de calculer les régions atteignables à temps borné, et peuvent donc montrer que la région n’est jamais atteinte sur
l’intervalle [0, τ ], pour τ fixé. Dans le reste de cet article, nous allons montrer qu’il
est possible de calculer en temps fini un invariant donnant une sur-approximation des
trajectoires concrètes pour un temps non borné.
Notons désormais Fh la fonction Fh : Σc × Σb → Σc × Σb telle que
∀n ∈ N, σc n+1 , σb n+1 = Fh σc n , σb n . Nous cherchons donc à calculer la
suite des itérées de Fh : Fh n (σc 0 , σb 0 ). Pour obtenir des invariants à temps non
borné, nous allons chercher des motifs périodiques dans cette suite. En particulier,
nous détecterons le cas où la suite est ultimement périodique, c’est-à-dire telle qu’il
existe N ∈ N (le rang) et K ∈ N (la période) tels que ∀n ∈ N, n ≥ N ⇒
Fh (n+K) (σc 0 , σb 0 ) = Fh (n) (σc 0 , σb 0 ). Si la suite n’est pas périodique, nous allons calculer une sur-approximation périodique de cette suite. Pour cela, nous allons
d’abord détecter le cycle, c’est-à-dire calculer les valeurs de N et K (en section 5.2.1),
puis nous calculerons les valeurs de σc n et σb n (en section 5.2.2).
5.2.1. Détection d’un cycle
Pour détecter le cycle, c’est-à-dire trouver la période de la suite Fh n , nous utilisons l’algorithme 2. À partir de l’état initial (σc 0 , σb 0 ), l’algorithme construit itérativement la suite (σc n , σb n ) : en partant d’une suite constante égale à (σc 0 , σb 0 ), on
calcule à chaque étape le prochain élément s = (σc , σb ) = Fh (σc i , σb i ), puis on
364
teste si un cycle existe. Si on trouve k ≤ i tel que σc v σc i et σb v σb i , alors il
existe un cycle de rang k et de période n−k + 1 : on peut donc arrêter le calcul. Sinon,
on cherche un élément de la suite qui soit proche de (σc , σb ), c’est-à-dire un élément
dont la distance 6 à s est inférieure à α. Si cet élément existe, cela signifie que l’on a
déjà calculé l’évolution du système depuis un état proche de s, on peut donc « forcer »
le cycle en modifiant la valeur de la suite : σc k = σc k t σc et σb k = σb k t σb . On
dit alors qu’on a détecté un « cycle approché » et on termine le calcul. Si aucun cycle
n’est détecté, on modifie la valeur suivante de la suite : σc i+1 = σc et σb i+1 = σb ,
puis on continue le calcul en partant du rang i + 1.
N
Le résultat de cet algorithme est donc une suite (σc n , σb n ) ∈ Σc × Σb ainsi
qu’un rang N ∈ N et une période K ∈ N . La suite n’est pas encore un invariant
pour les trajectoires du système hybride, mais le théorème 22 montre que c’est une
abstraction correcte des trajectoires jusqu’au temps t = (N − 1) × h.
T HÉORÈME 22. — Soit (σc n , σb n , K, N ) les valeurs calculées par l’algorithme
DetectionCycle. Alors, pour toute trajectoire continue (σcn , σbn ), on a :
∀k ∈ [0, N − 1], σck ∈ σc k .
Remarquons que l’algorithme ne fournit que des sur-approximations des trajectoires jusqu’au temps (N · h) car, lors de la détection d’un cycle approché, la valeur
de σc N peut avoir changé, il faut donc propager ce changement pour les autres éléments de la suite. C’est ce que nous faisons à la section 5.2.2.
Dans l’algorithme 2, le paramètre α est une heuristique permettant de contrôler
l’efficacité et la précision de l’algorithme. Plus α est grand, plus vite l’algorithme
termine (un cycle approché est détecté rapidement), mais l’approximation sera également plus grande. Un choix trop grand pour α est donc une source potentielle de
fausses alarmes : l’algorithme unifie deux états continus éloignés et introduit ainsi des
comportements nouveaux. Une autre heuristique nécessaire pour cet algorithme est
la stratégie de widening. En effet, la terminaison de l’algorithme 2 n’est pas garantie car il est possible qu’un cycle approché avec un paramètre α donné n’existe pas.
Pour contrer ce problème, nous utiliserons donc une technique proche du widening :
toutes les p itérations (p étant un paramètre fixé par l’utilisateur), α est augmenté jusqu’à atteindre α = +∞. Ainsi, on garantit la terminaison de l’algorithme, mais en
introduisant deux nouvelles heuristiques : le choix de p et la vitesse d’augmentation
de α. De ces heuristiques dépendent la vitesse de convergence de l’algorithme mais
également sa précision : en augmentant trop vite α, on peut introduire de faux comportements dans le système.
6. La distance que nous utilisons ici ne joue pas un rôle fondamental
dans la correction de l’algorithme.
Nous supposons donc avoir une fonction dS : Σc × Σb × Σc × Σb → R+ donnant la distance
entre deux états. En pratique, nous utiliserons la distance de Hausdorff, facile à calculer sur le domaine des
intervalles (voir (Bouissou, 2009) pour une définition exacte de la distance dS ).
365
Algorithme 2: DetectionCycle : détection et création d’un cycle dans la
trajectoire abstraite
Entrées : σc0 , σb0 , α ;
État initial et seuil
Entrées : Fh ;
Fonction de transfert abstraite
Sorties : Suites σc n , σb n , rang N et période K
début
σc n = σc0 ; σb n = σb0 ;
i = 0; K = 0;
tant que K = 0 faire
s = (σc , σb ) = Fh (σc i , σb i );
si ∃k ≤ i : s v (σc k , σn k ) alors
N = k; K = i − k + 1;
sinon
d = min{dS s, (σc k , σb k ) : k ≤ i};
si d > α alors
(σc i+1 , σb i+1 ) = s;
i = i + 1;
sinon
Choisit k ≤ i tel que dS (s, φ̃(k)) < α;
(σc k , σb k ) = σc k , σb k t s;
N = k; K = i − k + 1;
retourner φ, N, K
5.2.2. Calcul des valeurs
Après avoir détecté un cycle (ou un cycle approché) dans la trajectoire abstraite, il
faut calculer les valeurs des états abstraits pour tout instant k × h, k ∈ N. Pour cela,
on définit un opérateur FS : (Σc × Σb )N → (Σc × Σb )N sur les suites à valeurs dans
Σc × Σb qui propage la fonction de transfert abstraite Fh d’un élément de la suite à
l’autre. Cet opérateur dépend du rang N et de la période K calculés par l’algorithme 2,
et est défini par, pour tout φ ∈ (Σc × Σb )N , FS (φ) = φ0 avec :


φ(n)
∀n ∈ N, φ0 (n) = Fh (φ(N )) t Fh (φ(N + K))


Fh (φ0 (n − 1))
si n < N
si n = N
sinon
mod K .
P ROPOSITION 23. — La fonction FS est monotone sur le treillis complet des suites
(Σc × Σb )N muni de l’ordre point-à-point φ1 v φ2 ⇔ ∀n ∈ N, φ1 (n) v φ2 (n).
La proposition 23 nous permet de conclure que la fonction Fs a un plus petit
point fixe plus grand que (σcn , σbn ), la suite calculée par l’algorithme 2. En utilisant
l’itération de Kleene, on peut calculer ce point fixe. Le théorème 24 montre que ce
point fixe est un invariant des trajectoires d’un système hybride.
366
T HÉORÈME 24. — Soit Ω un système hybride et soit φ = (σc n , σb n ) la suite fournie
n
n
par l’algorithme 2. Soit (σc0 , σb0 ) la suite d’états abstraits, plus petit point fixe de
la fonction Fs supérieur à φ. Alors, pour toute trajectoire continue (σcn , σbn ) de Ω, on
n
n
a ∀n ∈ N, σcn ∈ σc0 et σbn ∈ σb0 .
n
n
Remarquons que la suite (σc0 , σb0 ) dans le théorème 24 est ultimement périodique, on peut donc la représenter de manière finie. Elle fournit donc un invariant fini
des trajectoires continues pour des temps non bornés.
Clairement, il est possible ici aussi d’utiliser le widening pour accélérer le calcul
du point fixe de Fs : nous utilisons le widening classique sur Σc , et l’appliquons
sur l’élément σc N de la suite, c’est-à-dire sur le premier élément de la trajectoire
périodique. Ceci introduit une autre source de sur-approximation pour les trajectoires
abstraites, mais garantit le calcul en un temps fini.
Dans cette section, nous avons donc montré comment calculer des invariants des
trajectoires continues pour des temps non borné. En partant d’une abstraction du programme sous forme d’un ensemble de k-trees (encodés dans la fonction LP Ma ), notre
algorithme essaie de détecter des cycles dans l’évolution des variables continues, en
modifiant les trajectoires abstraites pour créer de tels cycles si ils n’existent pas. Cette
technique a également été implémentée, nous obtenons pour des exemples classiques
de systèmes hybrides des résultats satisfaisants (voir (Bouissou, 2009) pour des résultats). La figure 9 montre l’invariant généré pour le problème des deux réservoirs avec
anticipation donné à la figure 4.
6. Travaux connexes
Ce travail étant à cheval entre plusieurs disciplines (sémantique et analyse des
langages de programmation, intégration garantie d’équations différentielles, modélisation et analyse de systèmes hybrides), il existe de nombreux travaux traitant d’au
moins une partie de ces sujets. Nous essayons ici de présenter quelques travaux importants sur ces différents thèmes.
Modélisation et analyse de systèmes hybrides. Les travaux fondateurs sur les automates hybrides (Alur et al., 1992 ; 1995) définissent un système hybride comme un
automate hybride, c’est-à-dire une extension des automates temporisés dans lesquels
les variables peuvent évoluer selon une équation différentielle ordinaire. Comme nous
l’avons déjà évoqué, la grande différence avec le modèle H-SIMPLE proposé dans
cet article est que l’exécution d’un automate hybride est dirigée par les évènements,
c’est-à-dire qu’un changement d’état discret a lieu dès lors qu’une garde est validée.
Au contraire, dans notre modèle, les changements ont lieu à des instants prédéfinis
et donnés par les instructions wait du système. Il semble possible d’encoder les
programmes H-SIMPLE en des automates hybrides en ajoutant des gardes portant
sur le temps à chacune des transitions possibles, cet encodage serait cependant
probablement peu efficace car le nombre d’états discrets risque d’être très important
dans le cadre d’un programme de grande taille. Les outils d’analyse de système
367
9
8
σc0
7
6
5
3
4
5
6
7
8
9
Figure 9. Trajectoire abstraite obtenue pour le programme de la figure 4. Chaque
carré représente un état continu abstrait (i.e. un couple d’intervalles pour h1 et h2 .
Les différents styles de traits représentent les différentes dynamiques (en fonction de
l’ouverture des vannes V1 et V2 )
hybride, des premiers travaux d’Henzinger (Henzinger et al., 1998) aux outils les
plus récents (Frehse, 2005 ; Frehse et al., 2011), cherchent à calculer les régions
atteignables par un automate hybride à temps borné uniquement. Tous ces outils
supposent que les dynamiques ainsi que les gardes du système hybride sont linéaires,
ce qui est une limitation forte de leur utilisation pour des programmes industriels.
Notons que les travaux les plus récents (Guernic, Girard, 2008 ; Girard, 2005) utilisent
le domaine des zonotopes pour encoder les ensembles de valeurs, domaine également
utilisé pour l’analyse statique de programmes numériques (Goubault, Putot, 2011).
Intégration garantie d’équations différentielles. Outre GRKLib (Bouissou, Martel,
2007), il existe plusieurs outils permettant de calculer des solutions garanties d’équations différentielles. Citons notamment les travaux fondateurs de Nedialkov sur le
logiciel VNODE (Nedialkov et al., 1999), qui calcule les bornes sur les solutions en
utilisant un développement de Taylor de l’équation différentielle, la série de Taylor
étant calculée par différentiation automatique. Ces idées ont été reprises et améliorées
dans les outils VSPODE (Lin, Stadtherr, 2007), qui utilisent des modèles de Taylor
pour gérer au mieux les dépendances de la solution à des paramètres inconnus, et
VALENCIA-IVP (Rauh et al., 2006). Notons que la plupart de ces outils utilisent
encore l’arithmétique d’intervalle pour calculer ces solutions garanties, et que les
368
limitations portant sur le type de dynamique sont faibles : les outils gèrent aussi
bien les dynamiques linéaires que non linéaires. Des techniques récentes permettent
de gérer les dynamiques non linéaires avec les outils développés pour les systèmes
hybrides : on parle alors d’hybridisation des dynamiques non linéaires (Asarin et al.,
2007 ; Dang et al., 2010).
Lien entre langages synchrones et modèles hybrides. La théorie des systèmes hybrides
est depuis le début développée essentiellement par des spécialistes de l’automatique,
il existe peu de liens entre la sémantique des langages de programmation et la théorie
des systèmes hybrides. Ma thèse a été un des premiers travaux dans cette direction,
plusieurs autres aspects ont depuis été développés. L’action INRIA Synchronics 7
vise à étudier le lien entre les langages synchrones (Lustre notamment) et les systèmes hybrides. Ainsi, des nouvelles sémantiques de modèles hybrides ont été proposées (Benveniste et al., 2011a ; 2011b) : ces travaux visent à apporter un cadre plus
proche des langages de programmation aux modèles classiques de systèmes hybrides.
De même, le lien entre Lustre et l’environnement physique a été étudié dans l’article (Briand, Jeannet, 2009) qui ont développé une méthode d’analyse ad hoc pour
le cas d’un automate hybride « synchrone ». Enfin, citons les travaux de (Chapoutot,
2008) qui vise à donner une sémantique formelle à Simulink, qui est probablement le
langage de modélisation de systèmes hybrides le plus utilisé mais également le moins
étudié.
7. Conclusion
Dans cet article, nous avons présenté un nouveau modèle pour représenter des systèmes hybrides, spécialement conçu pour décrire fidèlement le fonctionnement des
programmes de contrôle-commande. Pour cela, nous avons choisi de partir d’un langage de programmation simple, impératif, et avons ajouté trois primitives permettant
de gérer la communication entre le programme et son environnement physique. La
sémantique opérationnelle de ce langage est une extension simple de la sémantique
opérationnelle du langage initial, nous rajoutons essentiellement deux nouveaux types
de variables et une transition de délai qui modifie l’état de l’environnement physique
en faisant avancer le temps continu. Nous avons ensuite défini une méthode d’analyse permettant de calculer des sur-approximations des trajectoires de l’environnement
physique pour des temps non bornés. Pour cela, nous avons transformé le calcul de ces
trajectoires en le calcul d’un point fixe d’une fonction monotone opérant sur les suites
périodiques d’états abstraits. Cette fonction est construite à partir d’une abstraction
du programme sous forme d’un ensemble de k-trees et d’abstractions des dynamiques
continues calculées grâce à la théorie de l’intégration garantie.
7. http://synchronics.wiki.irisa.fr/tiki-index.php
369
Ces techniques ont fait l’objet d’une implémentation et les résultats expérimentaux
(qui sont disponibles dans (Bouissou, 2008) et (Bouissou, 2009)) montrent l’intérêt de
ces techniques spécialisées pour des programmes de contrôle-commande.
Il existe évidemment de nombreux points à améliorer pour rendre ces techniques
plus performantes et plus efficaces pour l’analyse de systèmes de contrôle-commande
industriels. Nous souhaitons notamment prendre en compte des actionneurs numériques, ce qui nécessite de définir un calcul de point fixe mixte entre le programme
et l’environnement continu. Nous voulons également utiliser des domaines relationnels pour l’intégration garantie d’équation différentielle (en nous inspirant du travail
de (Combastel, 2005)) pour améliorer le logiciel HybridFluctuat (Bouissou et al.,
2009) qui a débuté les travaux en ce sens.
Le travail futur qui nous semble le plus important est la question d’un widening
temporel, c’est-à-dire un opérateur permettant, en fonction des n premières étapes
de calcul, de sur-approximer l’évolution continue jusqu’à t = +∞. Pour l’instant,
nous recherchons des cycles dans l’évolution des variables continues pour pouvoir
traiter le temps non borné, cela nous oblige cependant à effectuer de grosses surapproximations dans les cas où ces phénomènes périodiques ne sont pas présents.
Plusieurs pistes nous semblent intéressantes pour améliorer notre analyse.
Si aucun cycle n’apparaît, on peut essayer de détecter dans l’évolution continue
une progression selon une suite arithmético-géométrique. Nous nous inspirons pour
cela des techniques développées dans (Feret, 2005) pour l’analyse des codes critiques embarqués : le domaine des progressions arithmético-géométriques relie les
valeurs des variables à l’intérieur d’une boucle avec un compteur i qui décrit le
nombre d’itérations de la boucle. Dans notre cas, on essaiera de relier la valeur des
variables avec le temps d’exécution du programme. Le domaine des progressions
arithmético-géométriques ne permet cependant que de détecter des progressions relativement simples pour les variables continues. Si les équations différentielles sont
fortement non linéaires, les sur-approximations risquent d’être trop importantes et
la précision trop faible. Une autre solution est alors d’utiliser les chaînes de récurrences (Bachmann et al., 1994 ; Pop, 2006), qui sont une extension des progressions
arithmético-géométriques. Les chaînes de récurrences ont été utilisées en compilation
pour déterminer à l’avance le nombre d’itérations dans une boucle (Pop, 2006). Les
motifs de la chaîne de récurrence sont calculés dynamiquement en fonction des valeurs successives prises par le système en x0 , x0 + h, x0 + 2h, . . . Les évolutions que
l’on peut obtenir sont plus variées qu’avec le domaine des progressions arithmeticogéométriques et on pourrait, en utilisant ces chaînes de récurrence, prédire la position
des variables continues pour tout instant de la forme t0 + i ∗ h, où h est l’intervalle de
temps entre deux mesures et i l’indice de la mesure.
Enfin, nous avons commencé des travaux (Bouissou, Seladji, Chapoutot, 2012)
sur l’utilisation de techniques d’extrapolation numérique pour améliorer le calcul de
point fixe en interprétation abstraite. Il nous semble possible d’utiliser des techniques
similaires pour calculer automatiquement, et rapidement, les limites des solutions des
équations différentielles, et ainsi définir un widening continu.
370
Bibliographie
Alur R., Courcoubetis C., Halbwachs N., Henzinger T. A., Ho P. H., et al. (1995). The algorithmic analysis of hybrid systems. Theoretical Computer Science, vol. 138, no 1, p. 3–34.
Alur R., Courcoubetis C., Henzinger T. A., Ho P. H. (1992). Hybrid automata: An algorithmic approach to the specification and verification of hybrid systems. In Hybrid systems i,
vol. 736, p. 209-229. Springer.
Asarin E., Dang T., Girard A. (2007, January). Hybridization methods for the analysis of
nonlinear systems. Acta Inf., vol. 43, p. 451–476.
Bachmann O., Wang P., Zima E. (1994). Chains of recurrences—a method to expedite the
evaluation of closed-form functions. In International symposium on symbolic and algebraic
computation (issac’94), p. 242–249. New York, NY, USA, ACM.
Benveniste A., Bourke T., Caillaud B., Pouzet M. (2011a, April). Divide and recycle: types and
compilation for a hybrid synchronous language. In ACM SIGPLAN/SIGBED Conference
on Languages, Compilers, Tools and Theory for Embedded Systems (LCTES’11). Chicago,
USA.
Benveniste A., Bourke T., Caillaud B., Pouzet M. (2011b). Non-standard semantics of hybrid
systems modelers. Journal of Computer and System Sciences (JCSS), Special issue in honor
of Amir Pnueli, vol. 78, no 3.
Birkhoff G. (1940). Lattice theory (vol. 25). American Mathematical Society.
Bouissou O. (2008). Analyse statique par interpretation abstraite de systèmes hybrides. Thèse
de doctorat non publiée, Ecole Polytechnique.
Bouissou O. (2009). Proving the correctness of the implementation of a control-command
algorithm. In J. Palsberg, Z. Su (Eds.), SAS, vol. 5673, p. 102-119. Springer.
Bouissou O., Goubault E., Goubault-Larrecq J., Putot S. (2012). A generalization of p-boxes
to affine arithmetic. Computing, vol. 94, p. 189-201. http://dx.doi.org/10.1007/s00607-011
-0182-8 (10.1007/s00607-011-0182-8)
Bouissou O., Goubault E., Putot S., Tekkal K., Védrine F. (2009). HybridFluctuat: A static
analyzer of numerical programs within a continuous environment. In A. Bouajjani, O. Maler
(Eds.), Cav, vol. 5643, p. 620-626. Springer.
Bouissou O., Martel M. (2007). GRKLib: a guaranteed runge-kutta library. In Follow-up of
international symposium on scientific computing, computer arithmetic and validated numerics. IEEE Press.
Bouissou O., Martel M. (2008). A hybrid denotational semantics of hybrid systems. In Proceedings of the 17th european symposium on programming languages and systems (esop’08),
vol. 4960, p. 63-77. Springer.
Bouissou O., Seladji Y., Chapoutot A. (2012). Acceleration of the abstract fixpoint computation
in numerical program analysis (accepted). Journal of Symbolic Computation.
Briand X., Jeannet B. (2009). Combining control and data abstraction in the verification of
hybrid systems. In Formal methods and models for codesign, memocode’2009. IEEE.
Chapoutot A. (2008). Simulation abstraite : une analyse statique de mod‘eles simulink. Thèse
de doctorat non publiée, Ecole Polytechnique.
371
Chen Y., Gansner E., Koutsofios E. (1997). A C++ data model supporting reachability analysis and dead code detection. In Proceedings of the 6th european software engineering
conference (ESEC/FSE 97), vol. 1301, p. 414–431. Springer. citeseer.ist.psu.edu/article/
chen98data.html
Combastel C. (2005). A state bounding observer for uncertain non-linear continuous-time
systems based on zonotopes. In 44 ieee conference on 44th ieee conference on decision and
control.
Cook B., Gotsman A., Podelski A., Rybalchenko A., Vardi M. (2007). Proving that programs
eventually do something good. SIGPLAN Notices, vol. 42, no 1, p. 265–276.
Cook B., Podelski A., Rybalchenko A. (2006a). Termination proofs for systems code. In
Proceedings of the 2006 acm sigplan conference on programming language design and
implementation (pldi’06), p. 415–426. ACM.
Cook B., Podelski A., Rybalchenko A. (2006b). Terminator: Beyond safety. In 18th international conference on computer aided verification (cav’06), vol. 4144, p. 415-418. Springer.
Cousot P. (2005). Proving program invariance and termination by parametric abstraction, lagrangian relaxation and semidefinite programming. In Proceedings of the sixth international conference on verification, model checking and abstract interpretation (vmcai’05), vol.
3385, p. 1–24. Springer. http://www.springerlink.com/content/qkufe4uekjgyja4f/
Cousot P., Cousot R. (1977). Abstract interpretation: a unified lattice model for static analysis
of programs by construction or approximation of fixpoints. In Conference record of the
fourth acm symposium on principles of programming languages (popl’77), p. 238–252.
ACM Press.
Cousot P., Cousot R. (1992a). Abstract interpretation frameworks. Journal of Logic and
Computation, vol. 2, no 4, p. 511–547.
Cousot P., Cousot R. (1992b). Comparing the Galois connection and widening/narrowing
approaches to abstract interpretation, invited paper. In Proceedings of the 4th international workshop programming language implementation and logic programming (plilp’92),
vol. 631, p. 269–295. Springer-Verlag.
Cousot P., Cousot R. (1994, 16–19 May). Higher-order abstract interpretation (and application
to comportment analysis generalizing strictness, termination, projection and PER analysis
of functional languages), invited paper. In Proceedings of the 1994 international conference
on computer languages, p. 95–112. Toulouse, France, IEEE Computer Society Press, Los
Alamitos, California.
Cousot P., Halbwachs N. (1978). Automatic discovery of linear restraints among variables of
a program. In Conference record of the fifth acm symposium on principles of programming
languages (popl’78), p. 84–97. ACM Press.
Dang T., Maler O., Testylier R. (2010). Accurate hybridization of nonlinear systems. In Proceedings of the 13th acm international conference on hybrid systems: computation and control,
p. 11–20. New York, NY, USA, ACM. http://doi.acm.org/10.1145/1755952.1755956
Feret J. (2005). The arithmetic-geometric progression abstract domain. In Proceedings of
the 6th international conference on verification, model checking and abstract interpretation
(vmcai’05), vol. 3385, p. 42–58. Springer.
Finkel R. A., Bentley J. L. (1974). Quad trees a data structure for retrieval on composite keys.
Acta Informatica, vol. 4, no 1, p. 1–9.
372
Frehse G. (2005). Phaver: Algorithmic verification of hybrid systems past hytech. In M. Morari,
L. Thiele (Eds.), Hybrid systems: Computation and control (HSCC 2005), vol. 3414, p. 258273. Springer.
Frehse G., Guernic C. L., Donzé A., Ray R., et al. (2011). Spaceex: Scalable verification of
hybrid systems. In Cav.
Girard A. (2005). Reachability of uncertain linear systems using zonotopes. In M. Morari,
L. Thiele (Eds.), Hybrid systems: Computation and control (HSCC 2005), vol. 3414, p. 291305.
Gonnord L., Halbwachs N. (2006). Combining Widening and Acceleration in Linear Relation
Analysis. In S. Verlag (Ed.), Static Analysis (SAS 2006), vol. 4134, p. 144-160.
Goubault E., Putot S. (2006). Static analysis of numerical algorithms. In Proceedings of the
13th international symposium on static analysis (sas’06), vol. 4134, p. 18-34. Springer.
Goubault E., Putot S. (2011). Static analysis of finite precision computations. In Proceedings of the 12th international conference on verification, model checking, and abstract interpretation, p. 232–247. Berlin, Heidelberg, Springer-Verlag. http://portal.acm.org/
citation.cfm?id=1946284.1946301
Guernic C. L., Girard A. (2008). Zonotope-hyperplane intersection for hybrid systems reachability analysis. In Proceedings of the international workshop on hybrid systems: Computation
and control (hscc’08), vol. 4981, p. 215–228. Springer.
Henzinger T. A. (1996). The theory of hybrid automata. In Symposium on logic in computer
science, p. 278–292. IEEE Computer Society Press.
Henzinger T. A., Ho P. H., Wong-Toi H. (1998). Algorithmic analysis of nonlinear hybrid
systems. IEEE Transactions on Automatic Control, vol. 43, p. 540–554.
Henzinger T. A., Horowitz B., Majumdar R., Wong-Toi H. (2000). Beyond HYTECH: Hybrid
systems analysis using interval numerical methods. In Third international workshop on
hybrid systems: Computation and control (hscc’00), vol. 1790, p. 130-144. Springer.
Heymann M., Lin F., Meyer G., Resmerita S. (2005). Analysis of zeno behaviors in hybrid
systems. IEEE Transactions on Automatic Control, vol. 50, no 3, p. 376-384.
Hoare C. A. R. (1985). Communicating sequential processes. Prentice-Hall.
Hymans C., Levillain O. (2008). Newspeak, Doubleplussimple Minilang for Goodthinkful Static
Analysis of C. Technical Note no 2008-IW-SE-00010-1. EADS IW/SE.
Lin Y., Stadtherr M. A. (2007). Validated solutions of initial value problems for parametric odes.
Applied Numerical Mathematics, vol. 57, no 10, p. 1145 - 1162. http://www.sciencedirect
.com/science/article/B6TYD-4MHPHBR-1/2/ea22e1b99246fda7914d438dbd090738
Lygeros J., Johansson K., Simic S., Zhang J., Sastry S. (2003). Dynamical properties of hybrid
automata. IEEE Transactions on Automatic Control, vol. 48, no 1, p. 2-17.
Miné A. (2004). Weakly relational numerical abstract domains. Thèse de doctorat non publiée,
École Normale Supérieur de Paris.
Monniaux D. (2009, June). A minimalistic look at widening operators. Higher Order Symbol.
Comput., vol. 22, p. 145–154. http://dx.doi.org/10.1007/s10990-009-9046-8
Nedialkov N. (2006). Interval tools for ODEs and DAEs. Rapport technique no CAS 06-09-NN.
Dept. of Computing and Software, McMaster University.
373
Nedialkov N., Jackson K., Corliss G. (1999). Validated solutions of initial value problems
for ordinary differential equations. Applied Mathematics and Computation, vol. 105, no 1,
p. 21–68.
Pop S. (2006). The ssa representation framework: Semantics, analyses and gcc implementation.
Thèse de doctorat non publiée, Ecole des Mines de Paris.
Putot S., Goubault E., Martel M. (2003). Static analysis-based validation of floating-point computations. In Numerical software with result verification, vol. 2991, p. 306-313. Springer.
Rauh A., Auer E., Hofer E. (2006). ValEncIA-IVP: A case study of validated solvers for initial
value problems. In International symposium on scientific computing, computer arithmetic
and validated numerics. IEEE.
Schrammel P., Jeannet B. (2010). Extending abstract acceleration methods to data-flow programs with numerical inputs. Electronic Notes in Theoretical Computer Science, vol. 267,
no 1, p. 101 - 114. (Proceeding of the Second International Workshop on Numerical and
Symbolic Abstract Domains: NSAD 2010)
Winskel G. (1993). The formal semantics of programming languages: an introduction. Cambridge, MA, USA, MIT Press.
Zhang J., Johansson K., Lygeros J., Sastry S. (2001). Zeno hybrid systems. International
Journal of Robust and Nonlinear Control, vol. 11, p. 435-451.
Olivier Bouissou. est ingénieur-chercheur au sein du laboratoire LMeASI du CEA LIST. Ses
travaux portent sur l’analyse statique par interprétation abstraite de programmes critiques
embarqués, en particulier l’analyse des interactions entre le programme et son environnement
physique. Il s’intéresse notamment à la qualité des méthodes numériques utilisées pour la
simulation de cet environnement physique, et développe des techniques de simulation garantie.

Vérification partielle de programmes de contrôle-commande

Transcription

Documents pareils

Guide de l`exposant - Salon Véhicule Électrique Montréal

IRTS Aquitaine Pôle des formations supérieures et continues ID/AA

Droits d`inscription : 590

courbeur_de_miroir_avec_positionneur

Proposition n. 141 soumise au Congrès de Paris (1954)

NP-FH70 - Afrivision

TESTY 2 Multimètre numérique de poche