Vérification mécanisée de la correction et complexité asymptotique de programmes

Cette thèse s’intéresse à la question de démontrer rigoureusement que l’implantation d’un algorithme donné est non seulement correcte (elle renvoie bien le bon résultat dans tous les cas possibles), mais aussi possède la bonne complexité asymptotique (elle calcule toujours ce résultat en le temps attendu).Pour les chercheurs en algorithmique, caractériser la performance d’un algorithme se fait généralement en indiquant sa complexité asymptotique, notamment à l’aide de la notation “grand O” due à Landau. Nous détaillons, tout d’abord informellement, pourquoi de telles bornes de complexité asymptotiques sont également utiles en tant que spécifications formelles. La raison est que celles-ci permettent de raisonner de façon modulaire à propos du coût d’un programme : une borne en O s’abstrait de l’expression exacte du coût du programme, et par là des divers détails d’implantation. Par ailleurs, nous illustrons, à l’aide d’exemples simples, un certain nombre de difficultés liées à l’utilisation rigoureuse de la notation O, et qu’il est facile de négliger lors d’un raisonnement informel.Ces considérations sont mises en pratique en formalisant d’une part la notation O dans l’assistant de preuve Coq, et d’autre part en étendant CFML, un outil existant dédié à la vérification de programmes, afin de permettre à l’utilisateur d’élaborer des démonstrations robustes et modulaires établissant des bornes de complexité asymptotiques. Nous étendons la logique de séparation avec crédits temps—qui permet de raisonner à la fois sur des propriétés de correction et de complexité en temps—avec la notion de crédits temps négatifs. Ces derniers augmentent l’expressivité de la logique, donnent accès à des principes de raisonnement commodes et permettent d’exprimer certaines spécifications de manière plus élégante. Au niveau des spécifications, nous montrons comment des bornes de complexité asymptotique avec O s’expriment en logique de séparation avec crédits temps. Afin d’être capable d’établir de telles spécifications, nous développons une méthodologie qui permet à l’utilisateur de développer des démonstrations qui soient à la fois robustes et menées à un niveau d’abstraction satisfaisant. Celle-ci s’appuie sur deux principes clefs : d’une part, un mécanisme permettant de collecter et remettre à plus tard certaines contraintes durant une démonstration interactive, et par ailleurs, un mécanisme permettant de synthétiser semi-automatiquement une expression de coût, et ce sans perte de généralité.Nous démontrons l’utilité et l’efficacité de notre approche en nous attaquant à un certain nombre d’études de cas. Celles-ci comprennent des algorithmes dont l’analyse de complexité est relativement simple (par exemple, une recherche dichotomique, déjà hors de portée de la plupart des approches automatisées) et des structures de données (comme les “binary random access lists” d’Okasaki). Dans notre étude de cas la plus significative, nous établissons la correction et la complexité asymptotique d’un algorithme incrémental de détection de cycles publié récemment. Nous démontrons ainsi que notre méthodologie passe à l’échelle, permet de traiter des algorithmes complexes, donc l’analyse de complexité s’appuie sur des invariants fonctionnels subtils, et peut vérifier du code qu’il est au final possible d’utiliser au sein de programmes réellement utiles et utilisés.This dissertation is concerned with the question of formally verifying that the imple- mentation of an algorithm is not only functionally correct (it always returns the right result), but also has the right asymptotic complexity (it reliably computes the result in the expected amount of time).In the algorithms literature, it is standard practice to characterize the performance of an algorithm by indicating its asymptotic time complexity, typically using Landau’s “big-O” notation. We first argue informally that asymptotic complexity bounds are equally useful as formal specifications, because they enable modular reasoning: a O bound abstracts over the concrete cost expression of a program, and therefore abstracts over the specifics of its implementation. We illustrate—with the help of small illustrative examples—a number of challenges with the use of the O notation, in particular in the multivariate case, that might be overlooked when reasoning informally.We put these considerations into practice by formalizing the O notation in the Coq proof assistant, and by extending an existing program verification framework, CFML, with support for a methodology enabling robust and modular proofs of asymptotic complexity bounds. We extend the existing framework of Separation Logic with Time Credits, which allows to reason at the same time about correctness and time complexity, and introduce negative time credits. Negative time credits increase the expressiveness of the logic, and enable convenient reasoning principles as well as elegant specifications. At the level of specifications, we show how asymptotic complexity specifications using O can be integrated and composed within Separation Logic with Time Credits. Then, in order to establish such specifications, we develop a methodology that allows proofs of complexity in Separation Logic to be robust and carried out at a relatively high level of abstraction, by relying on two key elements: a mechanism for collecting and deferring constraints during the proof, and a mechanism for semi-automatically synthesizing cost expressions without loss of generality.We demonstrate the usefulness and practicality of our approach on a number of increasingly challenging case studies. These include algorithms whose complexity analysis is relatively simple (such as binary search, which is nonetheless out of the scope of many automated complexity analysis tools) and data structures (such as Okasaki’s binary random access lists). In our most challenging case study, we establish the correctness and amortized complexity of a state-of-the-art incremental cycle detection algorithm: our methodology scales up to highly non-trivial algorithms whose complexity analysis intimately depends on subtle functional invariants, and furthermore makes it possible to formally verify OCaml code which can then actually be used as part of real world programs