Stratégies pour la réduction forte

Strategies for strong reduction

• Auteur / Autrice : Antoine Lanco
• Direction : Guillaume Melquiond, Thibaut Balabonski
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 15/12/2023
• Etablissement(s) : université Paris-Saclay
• Ecole(s) doctorale(s) : École doctorale Sciences et technologies de l'information et de la communication
• Partenaire(s) de recherche : référent : Faculté des sciences d'Orsay
• Partenaire(s) de recherche : graduate school : Université Paris-Saclay. Graduate School Informatique et sciences du numérique (2020-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire Méthodes formelles (Gif-sur-Yvette, Essonne ; 2021-....)
• Jury : Président / Présidente : Johanne Cohen
• Jury : Examinateurs / Examinatrices : Antonio Bucciarelli, Giulio Manzonetto, Delia Kesner
• Jury : Rapporteurs / Rapporteuses : Antonio Bucciarelli, Giulio Manzonetto

Mots clés

Mots clés contrôlés

Théorèmes -- Démonstration automatique

Méthodes formelles (informatique)

Réécriture, Systèmes de (informatique)

Lambda-calcul

Mots clés libres

Lambda-Calcul

Evaluation partielle

Normalisation

Lambda-Calculus

Partial evaluation

Normalization

Résumé

La sémantique d'un langage de programmation, et d'un langage fonctionnel en particulier, laisse généralement une certaine liberté quant à l'ordre dans lequel sont effectuées les différentes opérations. Les différentes stratégies qui peuvent être adoptées, comme l'appel par valeur ou l'évaluation paresseuse, bénéficient déjà à la fois d'un large corpus théorique et de nombreuses implémentations efficaces. Ce corpus cependant est majoritairement tourné vers un objectif d'évaluation des programmes, c'est-à-dire de production d'une valeur. Le cadre associé est celui de l'évaluation faible, dans lequel aucune évaluation n'est effectuée à l'intérieur d'une fonction qui ne serait pas totalement appliquée. En effet, dans un langage fonctionnel la clôture représentant une telle fonction est déjà en elle-même considérée comme une valeur.Cependant plusieurs situations justifient d'aller au-delà de ce cadre vers un objectif de normalisation, où la réduction est poussée jusqu'au bout, y compris à l'intérieur de ce qui est usuellement considéré comme une valeur. On parle alors de réduction forte. L'évaluation forte peut notamment intervenir comme un outil d'optimisation à la compilation, pour évaluer partiellement le corps d'une fonction en fonction de valeurs qui seraient déjà connues pour certains de ses arguments. Dans un autre contexte, cela concerne également l'implémentation des assistants à la preuve, avec par exemple dans Coq les différentes machines de conversion, en stratégie paresseuse, et de réduction, en appel par valeur.Malgré l'importance des applications, le corpus théorique fondant l'extension des stratégies usuelles de l'évaluation faible au cadre de la réduction forte reste très en-deçà du corpus traditionnel de l'évaluation faible, tant du point de vue du volume que de la maturité. Il se concentre sur quelques extensions particulières ou sur des cadres intermédiaires comme l'évaluation ouverte. Ces travaux, pour l'essentiel très récents, n'apportent cependant pas encore de réponses satisfaisantes à tous les nouveaux comportements observés en réduction forte, par exemple relatifs à l'explosion de la taille de certains termes. Par conséquent, les implémentations déjà réalisées utilisent souvent des stratégies ad hoc pour limiter l'impact de ces problèmes.Cette thèse définit un calcul en appel par nécessité avec réduction forte, c'est-à-dire des stratégies de normalisation qui étendent les stratégies usuelles d'évaluation en appel par nécessité. Le calcul utilise des substitutions explicites afin de supprimer certains effets d'explosion de la taille des termes. Par ailleurs, les stratégies détectent de manière précoce certains radicaux nécessaires, réduisant ainsi le nombre de calculs dupliqués.De plus, notre calcul bénéficie de propriétés de correction (les résultats obtenus correspondent bien à des formes normales du lambda-calcul) et de complétude (pour tout terme normalisable, nos stratégies atteignent bien la forme normale). Nous avons formalisé ce calcul et prouvé sa correction avec l'assistant de preuve Abella.Parmi les stratégies autorisées par notre calcul, nous en avons isolé une qui produit systématiquement les séquences de réduction les plus courtes, et défini et implémenté une machine abstraite qui réalise cette stratégie. L'implémentation a permis de réaliser un grand nombre de tests qui confirment les gains attendus par rapport aux stratégies d'évaluation usuelles.

Semantics of a programming language, especially functional ones, usually leaves underspecified the order in which the various operations are performed. Some usual strategies, such as call by value or lazy evaluation, already benefit from a large theoretical corpus as well as numerous efficient implementations. This corpus, however, mainly focuses on program evaluation, that is, producing a value. This is the framework of weak evaluation, in which no evaluation is performed inside a function that is not fully applied. Indeed, in a functional language, the closure that represents such a function is already considered as a value.Yet, several situations necessitate to go further and to look at normalization, which means that reduction is performed as far as possible, including in objects that are already values. That is called strong reduction. Among other things, strong evaluation can be used as an optimization pass during compilation, in order to partly evaluation the body of a function depending on the already known values of some of its arguments. Strong evaluation is also used inside proof assistants, for example Coq's machines of conversion (lazy strategy) and of reduction (call by value).Despite the importance of these applications, the theoretical corpus that extends the usual strategies from weak evaluation to strong reduction is way less comprehensive than the corpus for weak evaluation. It either focuses on some specific extensions or on some intermediate frameworks such as open evaluation. These works, very recent for the most part, do not yet bring any satisfying explanation to the way strong reduction behaves, for example the size explosion of some terms. As a consequence, the existing implementations often rely on some adhoc strategies to alleviate the impact of these issues.This thesis defines a call-by-need calculus with strong reduction, meaning a normalization strategies that extend the usual call-by-need evaluation strategies. The computation uses explicit substitutions to eliminate certain term size explosion effects, Furthermore, the strategies offer early detection of certain necessary redexes, thereby reducing the number of duplicated computations.Furthermore, our computation benefits from correctness properties (the obtained results correspond to normal forms of the lambda calculus), and completeness (for any normalizable term, our strategies reach the normal form). We have formalized our computation and prove its correctness with the Abella proof assistant.In this space, we have isolated a strategy that consistently produces the shortest reduction sequences and defined and implemented an abstract machine that executes this strategy. The implementation allowed us to conduct numerous tests which confirm the expected gains over conventional évaluation strategies.