Managing Logical and Computational Complexity using Program Transformations Nicolas Tabareau To cite this version: Nicolas Tabareau. Managing Logical and Computational Complexity using Program Transformations. Category Theory [math.CT]. université de nantes, 2016. tel-01406351 HAL Id: tel-01406351 https://tel.archives-ouvertes.fr/tel-01406351 Submitted on 1 Dec 2016 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Ecole´ Doctorale STIM UMR CNRS 6241 LINA Habilitation a` Diriger les Recherches Managing Logical and Computational Complexity using Program Transformations Rendre Compte de la Complexit´eLogique et Calculatoire `atravers des Transformations de Programmes pr´esent´eeet soutenue publiquement par Nicolas Tabareau le 24 novembre 2016 devant le jury compos´ede Thierry Coquand G¨oteborg University (examinateur) Hugo Herbelin Inria Paris (rapporteur) Daniel Hirschkoff Ens Lyon (rapporteur) Claude Jard Universit´ede Nantes (examinateur) Alan Schmitt Inria Rennes Bretagne Atlantique (rapporteur) Table of Contents Remerciementsv Introduction (en fran¸cais)1 Une Introspection R´etrospective..........................1 Ma Future Ligne de Recherche...........................4 1 Looking Back into the Future 17 1.1 A Retrospective Introspection......................... 17 1.2 Future Line of Reasearch........................... 20 2 Call-by-Name Forcing in Type Theory 31 2.1 Call-by-Push-Value............................... 33 2.2 Forcing Translation in the Negative Fragment................ 37 2.3 Yoneda to the Rescue............................. 40 2.4 Datatypes.................................... 42 2.5 Recursive Types................................ 43 2.6 Forcing at Work: Consistency Results.................... 47 2.7 Future Work.................................. 50 3 Chemical Foundations of Distributed Aspects 51 3.1 The distributed objective join calculus.................... 53 3.2 The aspect join calculus............................ 59 3.3 From the aspect join calculus to the join calculus.............. 66 3.4 Aspect JoCaml................................. 73 3.5 Discussion.................................... 76 3.6 Related work.................................. 77 4 Partial Type Equivalences for Verified Dependent Interoperability 81 4.1 Partial Type Equivalences........................... 85 4.2 Partial Type Equivalence for Dependent Interoperability.......... 89 4.3 Higher-Order Partial Type Equivalence................... 93 4.4 A Certified, Interoperable Stack Machine.................. 96 4.5 Related Work.................................. 101 4.6 Future Work.................................. 104 Appendix 107 Publications of the author 111 Bibliography 113 Remerciements Mains aux fleurs, Picasso (1958) Je voulais dire merci aux membres du jury. Qu'ils sachent que je suis tr`eshonor´ede leur pr´esence `ama soutenance. Je voulais dire merci `ames coll`egues, co-auteurs, ´etudiants ou post-docs, pour ces moments de partage et d'envol´ees scientifiques qui font de ce m´etier toute sa sp´ecificit´e. Je voulais dire merci `ames filles, pour leur spontan´eit´equi fait oublier en un clin d'œil toute contrari´et´e. Je voulais dire merci `ama princesse, pour sa fra^ıcheur toujours pr´esente apr`es ces 17 ann´ees qui nous unient. Introduction Le saut dans le vide, Klein (1960) Contents Une Introspection R´etrospective....................1 Aper¸cu du Reste du Manuscrit.......................4 Ma Future Ligne de Recherche.....................4 Objectifs pour les cinq prochaines ann´ees.................7 M´ethodologie................................. 11 Une Introspection R´etrospective Remarque 1 Bien que le reste de ce manuscrit soit ´ecrit de mani`ere conventionnelle, cette section est ´ecrite `ala premi`ere personne pour souligner le fait qu'elle d´eveloppe un point de vue personnel. La S´emantique de la Compilation. Durant mon stage au sein de Microsoft Research `aCambridge en 2007, j'ai commenc´e`a´etudier la s´emantique de la compilation des langages de programmation [BT09] sous la d´elicieuse supervision de Nick Benton. Mes int´er^ets scientifiques de l'´epoque portaient principalement sur la s´emantique d´enotationelle des langages de programmation, mais j'ai alors commenc´e`ar´ealiser1 que la compilation|ou plut^otla traduction|d'un programme ´ecrit dans un langage complexe de haut niveau vers un langage plus simple ´etait un moyen tr`es primitif et efficace pour donner un sens au programme complexe. 1J'ai aussi commenc´e`ar´ealiser que j'aimais beaucoup l'assistant de preuve Coq [CDT15], ce qui devrait ^etre clair `ala lecture du reste de ce manuscrit. 2 Introduction La Programmation par Aspects. Cette remarque m'a poursuivi alors que je com- men¸cais `a´etudier la s´emantique de la programmation par aspects lors de mon arriv´ee dans l'´equipe Ascola (Aspects Components Languages) en 2009. La programmation par aspects [KLM+97] est un paradigme de programmation qui a pour but d'accro^ıtre la modularit´edu code en permettant la s´eparation des propri´et´es transverses. Nous ap- pelons propri´et´etransverse une propri´et´equi ne peut pas ^etre d´efinie en utilisant les m´ecanismes de modularit´eclassiques, comme par exemple les classes, les modules ou les composants. Le calcul de la trace d'un programme ou les probl´ematiques de s´ecurit´e forment deux exemples de propri´et´estransverses, et sont donc sujettes `a´eparpillement et intrication. L'id´eede la programmation par aspects est de ramener toutes les parties du code qui traitent d'une propri´et´etransverse dans un m^eme endroit du programme, `a travers l'utilisation d'un nouveau type de module, appel´eun aspect. Les deux principaux constituants d'un aspect sont les coupes (pointcuts en anglais) et les advices2 Une coupe s´electionne les points d'ex´ecution d'int´er^etdu programme de base, par exemple, les appels de m´ethode dans le cas du calcul de trace. Un advice d´efinit ce qui doit ^etre fait lorsqu'un point d'ex´ecution est s´electionn´e,typiquement l'affichage d'un message avant et/ou apr`es un appel dans le cas de l'affichage de la trace d'un programme. Le processus qui consiste `acomposer des aspects avec un programme de base, afin d'obtenir une impl´ementation concr`ete du programme tel qu'il aurait ´et´e´ecrit sans aspect, s'appelle le tissage. Mon premier travail sur la s´emantique d'un calcul distribu´eavec aspects [Tab10] a ´et´eobtenu en traduisant ce calcul vers le \join calculus" [FG96a], consid´erant ainsi le tissage comme une transformation de programme. J'ai ensuite ´etudi´ela s´emantique de la programmation par aspects pour des langages fonctionnels [Tab11, Tab12], `ala lumi`ere de la traduction monadique, qui constitue une transformation de programme bien connue dans le cadre de la programmation fonctionnelle. Les monades [Mog91] fournissent un m´ecanisme pour embarquer et raisonner sur des effets comme les ´etats m´emoires, les entr´ees/sorties ou la gestion des exceptions, et ce dans un cadre purement fonctionnel comme dans Haskell. D´efinir de la s´emantique d'un langage fonctionnel avec aspects en utilisant une monade permet d'^etre modulaire sur les diff´erentes s´emantiques possibles des aspects (i.e., le d´eploiement d'aspects, la gestion des interf´erences entre aspects), et permet aussi une impl´ementation directe dans le langage, comme nous l'avons montr´esur Haskell [TFT13, FTT14b, FSTT14]. En utilisant des id´ees venant de la notion de port´eepour les aspects, j'ai d´evelopp´e, avec Ismael Figueroa et Eric´ Tanter, une d´efinition monadique de la notion de capacit´espour les effets [FTT14a, FTT15] dans Haskell, capacit´es qui permettent d'imposer certaines politiques de s´ecurit´esur les effets qui sont utilis´esdans un programme Haskell. En plus du cadre monadique, ce travail utilise crucialement le m´ecanisme de type classes de Haskell pour d´ecider statiquement du niveau de permission en se basant sur une impl´ementation du treillis des permissions avec des type classes. Le Forcing en Th´eorie des Types. Entre temps, j'utilisais de plus en plus Coq pour formaliser certaines parties des preuves que je faisais sur papier. Cela me fit prendre con- science que m^eme si la th´eorie des types (ou plus pr´ecis´ement le Calcul des Constructions Inductives, la th´eorie derri`ere Coq) est d´ej`atr`esexpressive, il manque cruellement la possibilit´ed'augmenter son contenu logique ou calculatoire facilement. Cela m'a amen´e`a d´evelopper avec Guilhem Jaber et Matthieu Sozeau une version du forcing pour la th´eorie des types [JTS12]. Le forcing est une m´ethode originellement d´evelopp´ee par Paul Co- hen pour prouver l'ind´ependance de l'hypoth`ese du continu avec la th´eorie des ensembles 2Je me permets cette francisation maladroite du terme \advice" utilis´edans la programmation par aspects qui constitue d´ej`aune utilisation lib´erale du terme anglais. Introduction 3 ZFC [Coh66]. L'id´ee principale est d'ajouter de nouveaux ´el´ements `ala th´eorie qui peu- vent ^etre approxim´es dans le syst`emeinitial, en utilisant ce qu'on appelle des conditions de forcing. Pour adapter cette id´ee`ala th´eorie des types, plut^otque d'utiliser l'approche habituelle du forcing `atravers la th´eorie des ensembles, nous avons utilis´esa reformulation en terme de th´eorie des cat´egories que Bill Lawvere et Myles Tierney [Tie72] ont d´evelopp´e en utilisant le topos des faisceaux. R´ecemment, les travaux de Jean-Louis Krivine [Kri11] et Alexandre Miquel [Miq11a] ont montr´eque les techniques li´ees au forcing sont d'un grand int´er^etpour l'extension de l'isomorphisme de Curry-Howard.