Les Types à Tailles et leurs Applications pour l'Analyse de Complexité dans le Pi-Calcul

Dans cette thèse, nous étudions des méthodes basées sur les systèmes de types à tailles pour la complexité en temps, en particulier pour l’analyse des processus du pi-calcul, un modèle basé sur les communications pour les calculs parallèles. L’idée centrale des types à tailles est de tracer la taille des valeurs d’un programme et d’utiliser cette information pour contrôler la récursion et en déduire des bornes de complexité en temps. Dans la première partie de cette thèse, nous nous intéressons à une approche théorique de la complexité, dans le cadre de la complexité computationnelle implicite (ICC). L’objectif de l’ICC est de caractériser des classes de complexité en utilisant la logique ou les types, généralement sans donner de bornes explicites. Plusieurs méthodes ont été développées pour la complexité en temps. Une approche principale vient de la logique linéaire, en utilisant des versions restreintes de la modalité "!", qui contrôle la duplication. Une autre approche est de se concentrer sur la taille des valeurs. Ces deux approches ont des défauts. La première approche induit une faible expressivité intentionnelle: certains programmes naturels en temps polynomial ne sont pas typables. Pour la seconde approche, elle est essentiellement linéaire, donc elle ne permet pas en particulier une utilisation non-linéaire des arguments d’ordres supérieurs. Dans cette thèse, nous surmontons ces contraintes en combinant les deux approches dans un système de type commun. Nous élaborons un système de type pour un langage abstrait fonctionnel qui autorise des arguments fonctionnels non-linéaires avec une expressivité intentionnelle vraisemblablement correcte. Notre approche se base sur la logique linéaire élémentaire combinée avec un système de types à tailles linéaires. Nous discutons de l’expressivité de ce système de type et nous prouvons qu’il donne une caractérisation des classes de complexité FPTIME et 2k-FEXPTIME. Dans la seconde partie de cette thèse, nous étudions l’analyse de complexité avec des types. Cette approche pour analyser la complexité des programmes est un sujet de recherche important, en particulier pour les langages fonctionnels dans lesquels la notion de composition est essentielle. Parmi toutes les approches possibles, nous nous intéressons aux types à tailles. Nous explorons comment utiliser ces types pour l’analyse de complexité parallèle dans le pi-calcul. Deux notions de complexités en temps sont étudiées: le temps de calcul total sans aucune parallélisation (travail), et le temps de calcul avec une parallélisation maximale (profondeur). Nous définissons des sémantiques opérationnelles pour refléter ces deux notions. La seconde sémantique est particulièrement importante car elle donne des preuves plus simple que d’autres notions apparentées à la profondeur. Nous présentons deux systèmes de types similaires à partir duquel on peut extraire une borne de complexité sur un processus. Ces systèmes sont inspirés à la fois par les types à tailles et les types entrée/sortie du pi-calcul, auxquels on ajoute des informations temporelles. Cependant, cette extension des types à tailles fonctionnels pour l’analyse de profondeur a une expressivité limitée, en particulier en présence de certains comportements concurrents comme les sémaphores. Dans le but d’avoir une analyse plus expressive, nous élaborons un système de type qui repose sur le concept des usages, utilisés originalement pour l’analyse des deadlocks.In this thesis, we study methods based on sized type systems for time complexity, especially for the analysis of processes in the pi-calculus, considered as a communication-based model for parallel computation. The main idea of sized types is to track the size of values in a program, and to use this information to control recursion and deduce time complexity bounds. In the first part of this thesis, we focus on a theoretical approach of complexity, following the lines of implicit computational complexity (ICC). The goal of ICC is to characterize complexity classes by means of logics or types, generally without explicit bounds. Several methods have been proposed to characterize time complexity classes. One approach comes from linear logic and restricted versions of its !-modality controlling duplication. Another approach is to focus on the sizes of values. However, both approaches suffer from limitations. The first one has a limited intensional expressivity, that is to say some natural polynomial time programs are not typable. Concerning the second approach, it is essentially linear, more precisely it does not allow for a non-linear use of higher-order arguments. In this thesis, we incorporate both approaches into a common type system, to overcome their respective constraints. We design a type system for an abstract functional language allowing non-linear functional arguments, with a seemingly good intensional expressivity. Our approach relies on elementary linear logic, combined with a system of linear sized types. We discuss the expressivity of this new type system and prove that it gives a characterization of the complexity classes FPTIME and 2k-FEXPTIME.In the second part of this thesis, we study complexity analysis with types. Type systems as a technique to analyse programs have been extensively studied, especially for functional programming languages where composition is essential. Among all the approaches for this, we focus on sized types. We explore how to extend those types to the analysis of parallel complexity in the pi-calculus. Two notions of time complexity are studied: the total computation time without parallelism (work) and the computation time under maximal parallelism (span). We define operational semantics to capture those two notions. The semantics for span is particularly important, as it allows for simpler proof methods than related notions. We present then two similar type systems from which one can extract a complexity bound on a process, inspired both by sized types and input/output types, with additional temporal information about communications. However, this extension of functional sized types for span analysis has limited expressivity, especially in presence of concurrent behaviours such as semaphores. Aiming for a more expressive analysis, we design a type system which builds on the concepts of usages, originally used for deadlock-freedom analysis