2025Activity reportProject-TeamCASH
RNSR: 201822804N- Research center Inria Lyon Centre
- In partnership with:Université Claude Bernard (Lyon 1), Ecole normale supérieure de Lyon, CNRS
- Team name: Compilation and Analyses for Software and Hardware
- In collaboration with:Laboratoire de l'Informatique du Parallélisme (LIP)
Creation of the Project-Team: 2019 June 01
Each year, Inria research teams publish an Activity Report presenting their work and results over the reporting period. These reports follow a common structure, with some optional sections depending on the specific team. They typically begin by outlining the overall objectives and research programme, including the main research themes, goals, and methodological approaches. They also describe the application domains targeted by the team, highlighting the scientific or societal contexts in which their work is situated.
The reports then present the highlights of the year, covering major scientific achievements, software developments, or teaching contributions. When relevant, they include sections on software, platforms, and open data, detailing the tools developed and how they are shared. A substantial part is dedicated to new results, where scientific contributions are described in detail, often with subsections specifying participants and associated keywords.
Finally, the Activity Report addresses funding, contracts, partnerships, and collaborations at various levels, from industrial agreements to international cooperations. It also covers dissemination and teaching activities, such as participation in scientific events, outreach, and supervision. The document concludes with a presentation of scientific production, including major publications and those produced during the year.
Keywords
Computer Science and Digital Science
- A1.6. Green Computing
- A2.1. Programming Languages
- A2.1.1. Semantics of programming languages
- A2.1.2. Imperative programming
- A2.1.4. Functional programming
- A2.1.6. Concurrent programming
- A2.1.7. Distributed programming
- A2.1.9. Synchronous languages
- A2.1.10. Domain-specific languages
- A2.1.11. Proof languages
- A2.2. Compilation
- A2.2.1. Static analysis
- A2.2.2. Memory models
- A2.2.3. Memory management
- A2.2.4. Parallel architectures
- A2.2.5. Run-time systems
- A2.2.6. GPGPU, FPGA...
- A2.2.8. Code generation
- A2.3.1. Embedded systems
- A2.5.1. Software Architecture & Design
- A2.5.3. Empirical Software Engineering
- A2.5.4. Software Maintenance & Evolution
- A4.5. Formal method for verification, reliability, certification
- A4.5.1. Static analysis
- A4.5.2. Model-checking
- A4.5.3. Program proof
- A7.2. Logic in Computer Science
- A7.2.1. Decision procedures
- A7.2.3. Interactive Theorem Proving
- A7.2.4. Mechanized Formalization of Mathematics
- A8.3. Geometry, Topology
- A8.4. Computer Algebra
- A8.5. Number theory
- A9.11. Generative AI
Other Research Topics and Application Domains
- B3.1. Sustainable development
- B5.4. Microelectronics
- B9.5.1. Computer science
- B9.5.2. Mathematics
- B9.6.10. Digital humanities
1 Team members, visitors, external collaborators
Research Scientists
- Christophe Alias [INRIA, Researcher, HDR]
- Cyril Cohen [INRIA, Researcher]
- Ludovic Henrio [CNRS, Researcher, HDR]
- Filippo Nuccio Mortarino Majno Di Capriglio [UNIV Jean Monnet, Senior Researcher, from Sep 2025]
- Gabriel Radanne [INRIA, ISFP]
- Yannick Zakowski [INRIA, Researcher, until Mar 2025]
Faculty Member
- Matthieu Moy [Team leader, UNIV LYON I, Associate Professor, HDR]
Post-Doctoral Fellow
- Theo Stoskopf [INRIA, Post-Doctoral Fellow]
PhD Students
- Gregoire Aubertin [INRIA, from Sep 2025]
- Samy Avrillon [LIP, from Sep 2025]
- Vivien Gachet [LIP, from Sep 2025]
- Vincent Mastain [INRIA, from Sep 2025]
- Emma Nardino [ENS Lyon]
- Oussama Oulkaid [ANIAH, CIFRE, until Sep 2025]
- Etienne Parent [INRIA, from Sep 2025]
- Arthur Pons [Commown, CIFRE, from Feb 2025]
- Alec Sadler [INRIA]
Interns and Apprentices
- Samy Avrillon [ENS Lyon, Intern, from Apr 2025 until Jul 2025]
- Nathan Chandanson [INRIA, Intern, from Mar 2025 until Jul 2025]
- Marius Goyet [INRIA, Intern, from Feb 2025 until Jun 2025]
- Théa Hervier [ENS Lyon, Intern, from Feb 2025 until Jul 2025]
- Loup Paul-Dauphin [ENS Lyon, Intern, from Feb 2025 until Jul 2025]
Administrative Assistant
- Elise Denoyelle [Inria]
External Collaborator
- Laure Gonnord [GRENOBLE INP, HDR]
2 Overall objectives
The overall objective of the CASH team is to design and develop ways to improve the quality of software. We work both on tools that help programmers write better programs, and compilers that turn these programs into efficient executables.
By improving the quality, we mean both the safety of programs and the efficiency of their execution. We notably provide programmers with better programming language constructs to express their intent: constructions that give them guarantees by-construction such as memory-safety, determinism, etc. When guarantees can't be obtained by construction, we also develop static analyses to detect bugs or to prove preconditions needed to apply program transformations. We use such guarantees to develop new optimizations to generate efficient code. All these contributions find their foundation and justification in the semantics of programs.
When it comes to high level programming constructs for parallelism, we develop a specific expertise in asynchronous computations and ruling out race-conditions in concurrent programs. In this realm, we propose new paradigms, but also contribute to the semantics of such programs. For instance, we design ways to specify the semantics using monadic interpreters, and use them to study the correctness of compilers.
We ensure safety guarantees both through type-systems and analyses, in vastly different contexts: from the verification of electrical circuits to the design of a new module systems for OCaml. As is recurrent in our work, we pragmatically adapt the approach to the practical application at hand.
We design code transformation for the efficient execution of programs, in particular targetting HPC. Our contributions in this realm extend the polyhedral model to make it applicable to a wider range of programs, and to bring its potential for optimisation to new kind of applications (e.g. parametric tiling, sparse structures, etc.). We also design optimisations for structured data such as trees, or more generally algebraic data types.
Our Approach and methodology.
We target a balance between theory and practice: problems extracted from industrial requirements often yield theoretical problems.
On the practical side, the CASH team targets applied research, in the sense that most research topics are driven by actual needs, discussed either through industrial partnership or extracted from available benchmarks.
The theoretical aspects ensure the coherency and the correctness of our approach, they are mostly based on formally defined semantics. The formalization of the different representations of the programs and of the analyses allow us to show that these different tasks are performed with the same understanding of the program semantics. Formalization is done either with pen-and-paper definitions and proofs, or through mechanized proofs using the Rocq prover1.
Our approach is to cross-fertilize between several communities. For example, the abstract interpretation community provides a sound theoretical framework and very powerful analysis, but these are rarely applied in the context of optimizing compilation. Similarly, the formal verification community is very active on software, and RTL hardware verification, but very few researchers applied it to transistor-level verification (lower-level than RTL).
Many of our contributions are “meta-contributions”, in the sense that we do not only provide final results, but also tools to help on the foundational aspects of these results. We provide theoretical and practical tools that are both used internally in the team to achieve our final results, and provided to researchers outside the team. For example, we provide tools to express and manipulate program semantics formally in novel ways instead of focusing only on certified compilers themselves. Also, our contributions to the polyhedral model not only propose new optimizations based on the model, but also general purpose tools to help other researchers to prototype new optimizations. This makes it a bit easier to target general purpose conferences where meta-results are slightly more valued provided they are proven to be applicable but makes our development efforts spread out into several unrelated projects.
3 Research program
The structure of the team is illustrated by Fig. 1 with 4 research directions, detailed below. Vertical shapes represent more fundamental aspects, while horizontal ones represent the applications. Note that three of these directions are an evolution of the first three research focuses in our past activities. The team is recognized and contributes mostly in the four identified axes. Obviously, every direction potentially intersects all the others, but we emphasize the intersections between the fundamental aspects and the applications. For example, in the work on static strong typing programming language constructs are designed to provide analyses with strong guarantees. The purpose of the direction semantics and proofs is to provide tools to certify correctness of optimizations and analyses. This complementarity is manifest in the ANR “Shannon Meet Cray” (sxc.inria.fr) started in 2025 aiming to design new computational models and languages for efficient data-processing that will require cooperation between language design, optimisations and analysis.
Research directions of the CASH team: programming language design, semantics and proofs, analysis, optimizations
More importantly than intersection between axes, we highlight that many of the contributions we envision are shared between members of the team, and/or with external collaborators.
3.1 Programming Language Design
While parallelism is one major field of research concerning programming languages, we still have a significant research agenda in sequential programming languages. The interplay between programming languages and static guarantees is still a major concern that drives most of our language designs, in particular our expertise on type systems drives many of our design choices as it is a very effective way to ensure static properties of programs.
Participants
Cyril Cohen , Ludovic Henrio , Matthieu Moy , Gabriel Radanne .
3.2 Semantics and Proofs
The team is, overall, interested in formalization and proofs. In this research direction, we push the degree of formalization as far as it can be pushed with machine-checked proofs, typically using the Rock prover (the new name of the “Coq proof assistant”). The following challenges in the organization of formal proofs arise: defining or reusing hierarchies of mathematical structures (adjunctions, monads, (co-)algebras, etc), transferring proofs between structures, or turning abstract algorithms in executable and efficient code.
Participants
Cyril Cohen , Ludovic Henrio , Gabriel Radanne .
3.3 Program Analysis and Verification
Our activities on program analysis serve two purposes: large scale verification, intended to find bugs in programs and circuits and help fixing them; and analysis to improve optimizing compilers (e.g. infer invariants that can be used by the optimizer) and language tools (e.g. use the type system to improve the tooling available for developers).
Participants
Christophe Alias , Ludovic Henrio , Matthieu Moy , Gabriel Radanne .
3.4 Optimizations and Program Transformations
We have a special focus on data transformations both in the context of functional compilation and imperative compilation; while ensuring the scalability of our optimizations. These are transverse topics that we address through the following several research directions, like memory representation of datatypes, automatic or semi-automatic parallelization, etc.
Participants
Christophe Alias , Cyril Cohen , Ludovic Henrio , Gabriel Radanne .
4 Application domains
The scope of targeted applications is wide, from specialized HPC applications on supercomputers to general purpose computing, from massively parallel applications to sequential code, from functional languages to imperative code, etc. Our main focus is software, but we also consider hardware, both as an execution platform for software, and as a research topic (hardware generation and hardware circuit analysis). What links all our activities is that our object of study is computer programs.
While a global approach links CASH activities and members, we do not have a single unified toolchain where all contributions would be implemented. Instead we try to attach ourself to existing frameworks. This implies that different activities of CASH target different application domains and potential end-users: OCaml ecosystem; Vellvm project for certified compilation; standalone prototype for memory layout for algebraic data types but this may evolve to a Rust implementation. In other words, we chose for each of our contributions its most relevant toolchain and/or application. This allows us to both use the best technical framework and to pick the best way to eventually reach our final users.
5 Social and environmental responsibility
Footprint of research activities
Although we do not have a precise measure of our carbon (and other environmental) footprint, the two main sources of impact of computer-science research activities are usually travel (plane) and digital equipment (lifecycle of computers and other electronic devices).
Many members of the CASH team are already in an approach of reducing their international travel, and hopefully the new solutions we had to set up to continue our activities during the COVID crisis will allow us to continue our research with a sustainable amount of travel, and using other forms of remote collaborations when possible.
As far as digital equipment is concerned, we try to extend the lifetime of our machines as much as possible.
Impact of research results
Many aspects of our research are meant to provide tools to make better programs, in particular avoid bugs and improve power-efficiency. It is very hard, however, to assess the actual impact of such research. For example, our work on avoiding bugs may either avoid waste of resource due to buggy software or help developers write code for larger, resource-consuming execution platforms. In many cases, improvements in power-efficiency lead to a rebound effect which may weaken the benefit of the improvement, or even lead to an increase in total consumption (backfire).
CASH provides tools for developers, but does not develop end-user applications. We believe the social impact of our research depends more on the way developers will use our tools than on the way we conduct our research.
Ludovic Henrio followed the “Atelier Sciences Environnements Sociétés Inria 2021” (atelier Sens) organized by Eric Tannier in June 2021. Then, for the voluntary Cash members, he has animated an atelier Sens during the Cash seminar in October 2021.
One line of research explicitly targets energy and environmental transition. We study the possibility of a degrowth in computing power, trying to tackle the issue both from the technical point of view (e.g. our memory-consumption measurements as part of the Fruganum project) and human sciences point of view. We started a CIFRE Ph.D on low-tech infrastructure with the company Commown, and plan to start a Ph.D co-supervised with a sociologist on the evolution of the complexity of programming languages in 2026.
6 Latest software developments, platforms, open data
6.1 Latest software developments
6.1.1 DCC
-
Name:
DPN C Compiler
-
Keywords:
Polyhedral compilation, Automatic parallelization, High-level synthesis
-
Functional Description:
Dcc (Data-aware process network C Compiler) compiles a regular C kernel to a data-aware process network (DPN), a dataflow intermediate representation suitable for high-level synthesis in the context of high-performance computing. Dcc has been registered at the APP ("Agence de protection des programmes") and transferred to the XtremLogic start-up under an Inria license.
- Publication:
-
Contact:
Christophe Alias
-
Participant:
2 anonymous participants
6.1.2 PoCo
-
Name:
Polyhedral Compilation Library
-
Keywords:
Polyhedral compilation, Automatic parallelization
-
Functional Description:
PoCo (Polyhedral Compilation Library) is framework to develop program analysis and optimizations in the polyhedral model. PoCo features polyhedral building blocks as well as state-of-the-art polyhedral program analysis. PoCo has been registered at the APP (“agence de protection des programmes”) and transferred to the XtremLogic start-up under an Inria licence.
-
News of the Year:
This year, PoCo was enhanced with: - a program equivalence procedure - a scalarization/data systolization procedure PoCo kernel was enhanced with: - an interface to ISL affine relations - a generic solver for systems of regular langage equations - handling of programs with reductions - generation of systems of affine recurrence equations with reductions
- URL:
-
Contact:
Christophe Alias
-
Participant:
an anonymous participant
6.1.3 fkcc
-
Name:
The Farkas Calculator
-
Keywords:
DSL, Farkas Lemma, Polyhedral compilation
-
Scientific Description:
fkcc is a scripting tool to prototype program analyses and transformations exploiting the affine form of Farkas lemma. Our language is general enough to prototype in a few lines sophisticated termination and scheduling algorithms. The tool is freely available and may be tried online via a web interface. We believe that fkcc is the missing chain to accelerate the development of program analyses and transformations exploiting the affine form of Farkas lemma.
-
Functional Description:
fkcc is a scripting tool to prototype program analyses and transformations exploiting the affine form of Farkas lemma. Our language is general enough to prototype in a few lines sophisticated termination and scheduling algorithms. The tool is freely available and may be tried online via a web interface. We believe that fkcc is the missing chain to accelerate the development of program analyses and transformations exploiting the affine form of Farkas lemma.
-
Release Contributions:
- Script language - Polyhedral constructors - Farkas summation solver
- URL:
- Publication:
-
Contact:
Christophe Alias
-
Participant:
an anonymous participant
6.1.4 Vellvm
-
Keywords:
Coq, Semantic, Compilation, Proof assistant, Proof
-
Scientific Description:
A modern formalization in the Coq proof assistant of the sequential fragment of LLVM IR. The semantics, based on the Interaction Trees library, presents several rare properties for mechanized development of this scale: it is compositional, modular, and extracts to a certified executable interpreter. A rich equational theory of the language is provided, and several verified tools based on this semantics are in development.
-
Functional Description:
Formalization in the Coq proof assistant of a subset of the LLVM compilation infrastructure.
- URL:
-
Contact:
Yannick Zakowski
-
Participant:
4 anonymous participants
-
Partner:
University of Pennsylvania
6.1.5 ribbit
-
Keywords:
Compilation, Pattern matching, Algebraic Data Types
-
Functional Description:
Ribbit is a compiler for pattern languages with algebraic data types which is parameterized by the memory representation of types. Given a memory representation, it generates efficient and correct code for pattern matching clauses.
- URL:
-
Contact:
Gabriel Radanne
6.1.6 adtr
-
Name:
ADT Rewriting language
-
Keywords:
Compilation, Static typing, Algebraic Data Types, Term Rewriting Systems
-
Functional Description:
ADTs are generally represented by nested pointers, for each constructors of the algebraic data type. Furthermore, they are generally manipulated persistently, by allocating new constructors.
ADTr allow representing ADTs in a flat way while compiling a pattern match-like construction as a rewrite on the memory representation. The goal is to then use this representation to optimize the rewriting and exploit parallelism.
- URL:
- Publication:
-
Contact:
Gabriel Radanne
-
Participant:
3 anonymous participants
6.1.7 dowsing
-
Keywords:
Static typing, Ocaml
-
Functional Description:
Dowsing is a tool to search function by types. Given a simple OCaml type, it will quickly find all functions whose types are compatible.
Dowsing works by building a database containing all the specified libraries. New libraries can be added to the database. It then builds an index which allow to quickly answer to requests.
- URL:
- Publication:
-
Contact:
Gabriel Radanne
-
Participant:
2 anonymous participants
6.1.8 odoc
-
Keyword:
Ocaml
-
Functional Description:
OCaml is a statically typed programming language with wide-spread use in both academia and industry. Odoc is a tool to generate documentation of OCaml libraries, either as HTML websites for online distribution or to create PDF manuals and man pages.
- URL:
-
Contact:
Gabriel Radanne
-
Participant:
4 anonymous participants
6.1.9 PoLA
-
Name:
PoLA: a Polyhedral Liveness Analyser
-
Keywords:
Polyhedral compilation, Array contraction
-
Functional Description:
PoLA is a C++ tool that optimizes the footprint of C(++) programs of the polyhedral model by applying efficient memory mappings deduced from dynamic analysis of the program. More precisely, we apply a fine-grain liveness analysis on execution traces of a program, obtained either by execution or interpretation, and infer parametrized mappings for the arrays used for intermediate computations.
- URL:
- Publications:
-
Contact:
Christophe Alias
-
Participant:
3 anonymous participants
-
Partner:
Waseda University
6.1.10 Actors-OCaml
-
Keywords:
Concurrency, Ocaml
-
Functional Description:
An actor library for OCaml
- URL:
-
Contact:
Gabriel Radanne
6.1.11 ctrees
-
Name:
Choice Trees
-
Keywords:
Coq, Concurrency, Formalisation, Semantics, Proof assistant
-
Functional Description:
We develop so-called "ctrees", a data-structure in Coq suitable for modelling and reasoning about non-deterministic programming languages as an executable monadic interpreter. We link this new library to the Interaction Trees project: ctrees offer a valid target for interpretation of non-deterministic events.
- URL:
-
Contact:
Yannick Zakowski
6.1.12 ERCtool
-
Name:
Electrical Rule Checking Tool
-
Keywords:
Verification, Model Checking, Electrical circuit, Transistor, Program verification, Formal methods
-
Functional Description:
ERCtool is developed as part of a collaboration with the Aniah company, specialized in the verification of electric properties on circuits. A specificity of ERCtool is that it allows the analysis of a circuit with multiple power-supplies, and allows getting formal guarantees on the absence of error.
-
Contact:
Matthieu Moy
-
Partner:
Aniah
6.1.13 Math-Components
-
Name:
Mathematical Components library
-
Keywords:
Proof assistant, Coq, Formalisation
-
Functional Description:
The Mathematical Components library is a set of Coq libraries that cover the prerequisites for the mechanization of the proof of the Odd Order Theorem.
- URL:
-
Contact:
Assia Mahboubi
-
Participant:
15 anonymous participants
6.1.14 Math-comp-analysis
-
Name:
Mathematical Components Analysis
-
Keywords:
Proof assistant, Coq, Formalisation
-
Functional Description:
This library adds definitions and theorems to the Math-components library for real numbers and their mathematical structures.
-
Release Contributions:
First major release, several results in topology, integration, and measure theory have been added.
- URL:
- Publications:
-
Contact:
Cyril Cohen
-
Participant:
12 anonymous participants
-
Partners:
Ecole Polytechnique, AIST Tsukuba, Onera
6.1.15 Hierarchy Builder
-
Keywords:
Metaprogramming, Rocq
-
Scientific Description:
It is nowadays customary to organize libraries of machine-checked proofs around hierarchies of algebraic structures. One influential example is the Mathematical Components library, on top of which the long and intricate proof of the Odd Order Theorem could be fully formalized. Still, building algebraic hierarchies in a proof assistant such as Rocq requires a lot of manual labor and often deep expertise in the prover's internals. Moreover, according to our experience, making a hierarchy evolve without breaking client code is equally tricky: even a simple refactoring such as splitting a structure into two simpler ones is hard to get right.
Hierarchy Builder is a high-level language to build hierarchies of algebraic structures and to evolve these hierarchies without breaking user code. The key concepts are factory, builder, and abbreviation, which let the hierarchy developer describe an actual interface for their library. Behind that interface, the developer can provide appropriate code to ensure backward compatibility.
We implement the Hierarchy Builder language in the hierarchy-builder add-on for the Rocq system using the Elpi extension language.
-
Functional Description:
Hierarchy Builder is a high-level language for Rocq to build hierarchies of algebraic structures and to evolve these hierarchies without breaking user code. The key concepts are factory, builder, and abbreviation, which let the hierarchy developer describe an actual interface for their library. Behind that interface, the developer can provide appropriate code to ensure backward compatibility.
-
Release Contributions:
Compatible with Coq 8.18 to Coq 8.20. Added support for instance saturation
- URL:
- Publication:
-
Contact:
Enrico Tassi
-
Participants:
Kazuhiko Sakaguchi, Enrico Tassi, Cyril Cohen
-
Partners:
University of Tsukuba, Onera
6.1.16 Trocq
-
Keywords:
Proof synthesis, Proof transfer, Coq, Elpi, Logic programming, Parametricity, Univalence
-
Functional Description:
Trocq is a modular parametricity plugin for Rocq (prototype), aimed at proof transfer. It translates a user goal into a related variant using the target data structures, along with a rich parametricity witness from which a justifying substitution function can be extracted.
The plugin features a hierarchy of parametricity witness types, ranging from structure-less relations to a novel formulation of type equivalence. This gathers several pre-existing parametricity translations (including univalent parametricity and CoqEAL) in a unified framework.
This modular translation performs fine-grained analysis and generates sufficiently rich witnesses to preprocess the goal — without always requiring full type equivalence. It enables proof transfer with the power of univalent parametricity while avoiding the univalence axiom when unnecessary.
The translation is implemented in Rocq-Elpi and features transparent, readable code aligned with a sequent-style theoretical presentation.
-
Release Contributions:
Support for the Prop sort
- URL:
- Publication:
-
Contact:
Cyril Cohen
-
Participants:
Cyril Cohen, Enzo Crance, Assia Mahboubi
-
Partner:
Mitsubishi Electric R&D Centre Europe, France
7 New results
This section presents the scientific results obtained in the evaluation period. They are grouped according to the directions of our research program.
7.1 Research direction 1: Programming Language Design
7.1.1 Actors, futures, and algebraic effects
Participants: Ludovic Henrio, Emma Nardino, Gabriel Radanne, Yannick Zakowski.
This work aims to provide high level language constructors for concurrency and parallelism like actors and futures using modern functional language constructs like algebraic effects. Actors have been implemented and successfully used in several industry-grade frameworks, such as Akka. Algebraic effects allow the precise modelling of operation with effects, while providing excellent composition properties. They have been used both as a fundamental primitive for theoretical study, but also used as effective building blocks to create new complex control and effectful operators. The new version of OCaml with multicore support promotes the use of algebraic effects to implement new concurrency primitives. We implemented actors using algebraic effects, and obtain a practical, efficient implementation of Actors for OCaml. We also optimize tail asynchronous calls, avoiding the creation of extra futures for representing the results and limiting the number of context-switch between threads.
This year we have continued our efforts on tail-modulo-async calls
- We proved the correction of our optimisation on tail asynchronous calls, and worked on the implementation and its practical evaluation. A research paper is under submission on the subject 25.
- in the context of the PhD thesis of Emma Nardino we also worked on the mechanized formalisation of the transformation, based on the Iris framework. Several technical difficulties and limitations of the framework make the approach difficult, but on the other side, such a proof would increase the expressiveness of the Iris framework itself, which sounds promising.
7.1.2 SxC: From Data-processing to SIMD
Participants: Etienne Parent, Loup Lobet, Gabriel Radanne, Matthieu Moy, Laure Gonnord, Charles Paperman.
The “Shannon meet Cray” (SxC) project aims to investigate the use of SIMD instructions, which provide fine-grained parallelism in CPUs, for data-processing such as text search or DNA processing. In particular, this project aims to leverage the theory of circuit complexity (introduced by Shannon) to leverage vectorized instruction (as pioneered in the Cray-1 supercomputer).
This year, we kickstarted the ANR project accepted in 2024 with a workshop in Lille. Etienne Parent started his PhD advised by Charles Paperman , Matthieu Moy and Gabriel Radanne on the design of a DSL for text and DNA processing that compiles to SIMD. Another PhD (Loup Lobet ) started simultanously in Lille advised by Laure Gonnord and Charles Paperman on the compilation aspects.
7.1.3 Software Ecosystems for Digital Frugality
Participants: Matthieu Moy, Guillaume Salagnac, Arthur Pons.
The environmental impact of digital equipment is a concern of growing importance. The carbon footprint of the domain is estimated to 2-4% and most scenario for the next decades anticipate a growth. Manufacturing digital devices requires a wide range of rare elements, that become rarer and rarer as we extract them and that are very hard to recycle. The current trajectory of the digital domain is not sustainable in the long term, and we will probably need to replace the current “infinite growth” paradigm with some form of degrowth in the future. Technological progress on efficiency may be part of the solution, but they are usually cancelled by rebound effect. We claim that a reflection on a potential reduction of the overall computational power is needed. If not well anticipated, a degrowth may be imposed to us rather than chosen. We started working on anticipating such digital degrowth scenarios.
We currently tackle the question of digital ecosystems (programming language, build tool chain, execution environments, editing tools) for frugal systems. Assuming the computational power of computers is reduced in the future, some tools stop being usable by lack of resources. We consider that the main bottleneck would be physical RAM. We developed a tool called mprobe that measures the memory consumption of a program or a set of programs, and a set of scripts to launch this tool on a variety of programs, written in different programming language. We measure both the resource needed to execute the programs, to build it (compile, link, etc.), and also the resource needed to build the tool chain itself. We are working on the analysis of the results. Preliminary results show that even “old” languages like C and C++ require relatively large amounts of RAM to build simple programs, and that interpreted languages like Python may be viable candidates, although their resource consumption in terms of CPU is higher. We also work on integrating mprobe in the Nix package manager, to make it easy to profile the build of any packaged program.
We also started a CIFRE Ph.D with the society Commown, that starts an activity of Managed Service Provider. The Ph.D studies the feasibility of low-tech systems to provide services to its customers. We target a long-term sustainable approach with the smallest possible environmental impact.
7.2 Research direction 2: Semantics and Proofs
7.2.1 Tooling for the Rocq prover: HB and Trocq
Participants: Cyril Cohen, Lucie Lahaye, Quentin Vermande, Reynald Affeldt [AIST, Japan], Matteo Calosci [University of Florence], Marie Kerjean [LIPN, Paris], Pierre Roux [Onera, Toulouse], Assia Mahboubi [Inria, Nantes], Kazuhiko Sakaguchi [LIP, ENS de Lyon], Vojtěch Štěpančík [Inria, Nantes], Enrico Tassi [STAMP, Inria, Sophia Antipolis].
This axis deals with the contribution to the Rocq prover libraries to either automate the structuring (using Hierarchy Builder) and transfer (using Trocq) of properties, or provide general mathematical results (using the mathematical components library).
Trocq is both a new calculus performing a variant of a parametricity translation to achieve transfer of theorems for the calculus of constructions 13, and a prototype plugin for the Rocq prover, which has been ported to the latest version of Rocq by 27.
Hierarchy Builder (HB) is a domain specific language integrated to Rocq and designed to formally describe hierarchies of mathematical structures (e.g. Groups, Rings, Vector Spaces, etc), their various equivalent axiomatisations, their generic theory and their instances. As the impact of this project grows, several axes have emerged. We also extend the Math-Components and math-comp-analysis libraries with several structures (including N-modules, semi-normed spaces, etc).
As part of his PhD, Quentin Vermande , together with Cyril Cohen , worked on extending the capabilities of HB to deal with both bundled and unbundled structures.
Cyril Cohen together with Matteo Calosci and Enrico Tassi worked on extending HB to support changing subject in structure, thus switch from inferring structure on a type to inferring structure on its operations and vice versa.
As part of Vojtěch Štěpančík 's PhD, we also worked towards the automated reconstruction of structure from partial descriptions, e.g.: reconstructing the definition of morphisms from the description of objects, the morphism part of a functor from the object part, and naturality properties.
7.2.2 Formalisation concentration inequalities in the Rocq proof assistant
Participants: Cyril Cohen, Reynald Affeldt [AIST, Japan], Alessandro Bruni [ITU Copenhagen], Pierre Roux [Onera, Toulouse], Takafumi Saikawa [Nagoya University].
We formalize a proof of concentration inequalities in Rocq, involving a theory of Lp spaces and bounding inequalities in probability theory, contributing to mathcomp analysis in passing.
This led to a publication 17.
7.2.3 Semantics of Probabilistic Programs Using s-Finite Kernels in Dependent Type Theory
Participants: Cyril Cohen, Reynald Affeldt [AIST, Japan], Ayumu Saito [Japan].
We extend previously published work with more examples and theorems for reasoning on probabilitic programs in the s-finite kernel semantics 11.
7.2.4 Applications of LLM to Formal Verification
Participants: Cyril Cohen, Théo Stoskopf, Guillaume Baudart [Inria Paris], Marc Lelarge [Inria Paris], Assia Mahboubi [Inria Nantes], Nicolas Tabareau [Inria Nantes], Jules Viennot [Inria Paris].
We explore the use of LLM for proof assistants in the LLM4Code Inria Challenge (« défi Inria »), around essentially three projects:
- Babel Formal 26, a prototype translation tool between CoC based proof assistants, using kernel translations and proof script decompilation,
- LLM4Docq 28, a documentation generating framework for computer formalized mathematical statements,
- CRRRocq a chain of thoughts agent with RAG and tool calling to generate proof in interaction with the Rocq prover.
7.2.5 Deterministic parallel programs
Participants: Ludovic Henrio, Yannick Zakowski, Violet Ka I Pun, Einar Broch Johnsen, Asmund Kløvstad.
This research direction is a collaboration between Ludovic Henrio , Yannick Zakowski and our Norwegian colleagues. First results were published in 2021 on a simple static criteria for deterministic behaviour of active objects. We are now extending this work to be able to ensure deterministic behaviour in more cases and to lay a theoretical background that will make our results more general and easier to adapt to different settings.
We have formalized in the Rocq prover a result by DeBruijn dating back from the 70th on proving confluence of a system. In the process, we have solved some mistakes in the existing proof, and generalised it in a way that will make it even more useful in the context of programming language semantics. We applied this theorem to prove the confluence of systems where many threads interact with a set of stateless servers organised as layers. The proof has revealed to be more difficult than expected but we finished it this year and published the results in CPP' 2026.
We plan to extend the application language to futures and more asynchronous behaviour.
7.2.6 Verified Compilation Infrastructure for Concurrent Programs
Participants: Nicolas Chappe, Ludovic Henrio, Yannick Zakowski.
The objective of this research direction is to provide semantic and reasoning tools for the formalization of concurrent programs and the verification of compilers for concurrent languages. In particular, we want to apply these results to the design of verified optimizing compilers for parallel high-level languages. We wish to proceed in the spirit of the approach advocated in Vellvm 33: compositional, modular, executable monadic interpreters based on Interaction Trees 32 are used to specify the semantics of the language, in contrast with more traditional transition systems. Proving correct optimizations for such concurrent languages naturally requires new proof techniques that we need to design as well. Last year had seen the successful publication of the ctrees project. This year we published the results of the previous year 192 and investigated the generalisation of the approach to a more expressive notion of (non-deterministic) composition nodes 24.
7.2.7 A new module system for OCaml
Participants: Clement Blaudeau, Didier Remy, Gabriel Radanne.
ML modules offer large-scale notions of composition and modularity. Provided as an additional layer on top of the core language, they have proven to be both vital to the working OCaml and SML programmers, and inspiring to other use-cases and languages. Unfortunately, their meta-theory remains difficult to comprehend, requiring heavy machinery to prove their soundness.
We study a translation from ML modules to to provide a new comprehensive description of OCaml modules, embarking on a journey right from the source OCaml module system, up to , and back. This year, we published a novel model systems that applies directly to OCaml, without using a translation to but still preserving its expressivity 12.
7.3 Research direction 3: Program Analysis and Verification
7.3.1 Formal Verification of Electric Properties on Transistor-Level Descriptions of Circuits
Participants: Oussama Oulkaid, Bruno Ferres, Ludovic Henrio, Matthieu Moy, Gabriel Radanne, Mehdi Khosravian.
We started discussions with the Aniah start-up in 2019, and started a formal partnership in 2022, with the recruitment of Bruno Ferres as a post-doc, and Oussama Oulkaid as a CIFRE Ph.D (co-supervised by Aniah, Verimag, and LIP). We developed a prototype verification tool. The tool compiles transistor-level circuit descriptions (CDL file format) to logical formula expressing the semantics of the circuit plus a property to verify, and uses an SMT solver (Z3) to check the validity of the property. The tool was successfully used on a real-life case study, and we showed that our approach can reduce the number of false-alarms significantly compared to traditional approaches, with a reasonable computational cost (under a second for most sub-circuits analyzed). To the best of our knowledge, formal methods like SAT/SMT-solving were never applied to multi-supplies electronic circuits before. The technique experimented in the prototype was successfully re-implemented in the production tool commercialized by Aniah and is now available in the released version.
In 2025, we finished the validation of a richer semantics able to take into account more quantitative aspects on the circuits under analysis, and applied it to circuit reliability analysis (find the worst-case configuration in terms of circuit aging) and electrical over-stress (check that the voltage difference applied to each transistor is never larger than a maximum allowed value). The quantitative semantics was published in the TCAD journal 16, and the application to worst-case aging was submitted in the same journal.
In parallel with the technical work, we conducted a thorough review of existing work on the domain which was published as a survey in the TODAES journal 15.
The thesis of Oussama Oulkaid was defended on 21st of November 2025.
7.4 Research direction 4: Optimizations and Program Transformations
7.4.1 Automatic Specialization of Dense Code on Sparse Structures
Participants: Alec Sadler, Christophe Alias.
This work is concerned with the automatic parallelization of sparse code. Our approach is to specialize at runtime a canonical dense kernel on a sparse structure and to extract the runtime kernels to be distributed on the target architecture. This year, we focused on the specialization part. We proposed an algorithm able to propagate the sparsity across a dense computation, which may includes reductions. Our approach leverages an abstraction using regular expressions and particularly Kleene iterations to summarize the effect of loop nests. Experimental evaluation shows the precision of our approach.
These results are part of the PhD thesis of Alec Sadler and were presented at IMPACT'25 20.
7.4.2 Code Cartography
Participants: Alec Sadler, Christophe Alias.
This contribution is the next step of our sparse parallelization framework. Once the dense code have been specialized on a sparse input data, we want to recognize parts which might be implemented with a BLAS sparse kernel. We address this problem with a novel approach, able to cartography the code i.e. decide for a parametrized slice of code which algorithm it implements, provided a database of reference algorithms. We propose a preliminary algorithm to solve this problem on general polyhedral programs. Our procedure relies on a parametric program slicing, followed by an template matching method able to compare two parametrized polyhedral programs.
This on-going work is part of the PhD thesis of Alec Sadler. It is still under implementation.
7.4.3 Towards Optimising Programs with Sketch-Guided Polyhedral Compilation
Participants: Valeran Maytie, Reuben Carolan, Christophe Alias, Cedric Bastoul, Thomas Kœhler.
When programmers use semi-automatic compilers, they typically write optimisation scripts, to guide the compiler towards key optimisations. Instead of writing scripts, it may be preferable to write sketches that focus on the desired structure of the optimized code, without worrying about individual transformations. In this work, we propose a new semi-automatic, sketch-guided compilation approach. We introduce a sketch language that enables expressing the result of imperative loop transformations and a new polyhedral algorithm capable of generating code constrained by both a sketch and a computation specification.
This is a joint work with the Inria CAMUS team, these results are part of the PhD thesis of Valeran Maytie and will be presented at IMPACT'26.
7.4.4 New Insights on Scalar Promotion with the Polyhedral Model
Participants: Alec Sadler, Nathan Chandanson, Hugo Thievenaz, Christophe Alias.
Memory accesses are a well known bottleneck whose impact might be mitigated by using properly the memory hierarchy until registers. In this paper, we address scalar promotion, a technique to turn temporary arrays into a collection of scalar variables to be allocated to registers. We revisit array scalarization in the light of the recent advances of the polyhedral model. We propose a general algorithm for array scalarization and we show a scalarization of stencil computations thanks to a preliminary preprocessing. Our scalarization algorithm operates on the polyhedral intermediate representation and could be plugged in a polyhedral compiler among other passes. In particular, our scalarization algorithm is parametrized by the program schedule, possibly computed by a previous compilation pass. Experimental results confirm the effectiveness and the efficiency of our approach.
These results will be presented at IMPACT'26.
7.4.5 Memory optimizations for Algebraic Data Types
Participants: Thaïs Baudon, Vivien Gachet, Marius Goyet, Gabriel Radanne, Ludovic Henrio, Laure Gonnord.
Algebraic Data Types (ADT) have emerged as an incredibly effective tool to model and manipulate data in programs. ADTs also provide numerous advantages for optimizing compilers, as the rich declarative description allows choosing the memory representation of the types. Initially found in functional programming languages such as OCaml and Haskell, ADT have found their ways in languages such as Rust, which allows aggressive optimisations of their memory representation.
Ribbit (2, 6.1.5) is a prototype language and compiler which allow programmers to annotate ADTs with complex memory representation, and compile the rest of the code accordingly.
This year, we redesigned Ribbit's compilation algorithm to be more general and easier to implement, in preparation for trying to implement it in broader contexts. As part of the internship of Marius Goyet , we designed a new verification algorithm for memory layout, and implemented it in Ribbit. Finally, Vivien Gachet started his PhD supervised by Ludovic Henrio and Gabriel Radanne on the extension of Ribbit to mutable and concurrent data-structures.
8 Bilateral contracts and grants with industry
8.1 Partnership with the Aniah startup on circuit verification
Participants: Bruno Ferres, Matthieu Moy, Ludovic Henrio, Gabriel Radanne, Oussama Oulkaid.
The CASH team started discussion with the Aniah startup in 2019, to work on verification of electrical properties of circuits at transistor level. We recruited a post-doc (Bruno Ferres) in March 2022, and formalized the collaboration with a bilateral contract (Réf. Inria : 2021-1144), in parallel with a joint internship with LIP, Verimag laboratory and Aniah (Oussama Oulkaid), which led to a CIFRE Ph.D (LIP/Verimag/Aniah) started in October 1st 2022. The collaboration led to the development of a prototype tool, which served a the basis for the re-implementation of the approach in the production tool, and to 4 articles in major conference and journals, plus one ongoing submission.
8.2 CAVOC Project with Inria/Nomadic Labs
Participants: Guilhem Jaber, Gabriel Radanne, Laure Gonnord.
This project aims to develop a sound and precise static analyzer for OCaml, that can catch large classes of bugs represented by uncaught exceptions. It will deal with both user-defined exceptions, and built-in ones used to represent error behaviors, like the ones triggered by failwith, assert, or a match failure. Via “assert-failure” detection, it will thus be able to check that invariants annotated by users hold. The analyzer will reason compositionally on programs, in order to analyze them at the granularity of a function or of a module. It will be sound in a strong way: if an OCaml module is considered to be correct by the analyzer, then one will have the guarantee that no OCaml code interacting with this module can trigger uncaught exceptions coming from the code of this module. In order to be precise, it will take into account the abstraction properties provided by the type system and the module system of the language: local values, abstracted definition of types, parametric polymorphism. The goal being that most of the interactions taken into account correspond to typeable OCaml code.
This project is part of the partnership between Inria and Nomadic Labs, and lead by Guilhem Jaber , from the Inria Team Galinette.
9 Partnerships and cooperations
9.1 International initiatives
9.1.1 Associate Teams in the framework of an Inria International Lab or in the framework of an Inria International Program
Inria Associate Team FormaSys
Participants: Cohen Cyril, Vermande Quentin.
-
Title:
FormaSys
-
Partner Institution(s):
- AIST, Japan
- Universiry of Nagoya, Japan
- University of Kyoto, Japan
-
Date/Duration:
3 years
-
Additionnal info/keywords:
Formalization of mathematics, Rocq, mathcomp, cyberphysical systems
9.1.2 Participation in other International Programs
ANR PRCI MLOpt
Participants: Christophe Alias, Ali Jannesari, Sid Touati.
-
Title:
MLOpt – Machine Learning for Code Optimization
-
Partner Institution(s):
- Inria Lyon
- Université Côte d'Azur/CNRS
- Iowa State University
-
Date/Duration:
3 years
-
Additionnal info/keywords:
Code Optimization, Machine Learning, Translation Validation, Program Repair
9.2 National initiatives
PEPR NumPex, ExaSoft Project (WP2, Task 2.3)
Participants: Alec Sadler, Christophe Alias, Thierry Gautier, Xavier Rival, Philippe Clauss.
-
Title:
Polysparse – Compiling Sparse Kernels by Specialization
-
Partner Institution(s):
Inria Paris (X. Rival), Inria Nancy (P. Clauss)
-
Date/Duration:
6 years, started on September 2023.
-
Additionnal info/keywords:
Compilers, HPC, Polyhedral Model, Sparse Computation
Action exploratoire ProgReco
Participants: Christophe Alias, Sid Touati.
-
Title:
PolyReco – Program Recognition with Machine Learning
-
Partner Institution(s):
Université Côte d'Azur, Inria Lyon
-
Date/Duration:
4 years
-
Additionnal info/keywords:
Compilers, Program Analysis, Machine Learning
ANR CoREACT
Participants: Cohen Cyril.
-
Title:
CoREACT
-
Partner Institution(s):
IRIF, école polytechnique, Inria d'Université côte d'Azur
-
Date/Duration:
4 years
-
Additionnal info/keywords:
graph rewriting, category therory, Rocq
10 Dissemination
10.1 Promoting scientific activities
10.1.1 Scientific events: organisation
Member of the organizing committees
- Cyril Cohen : Steering committee of ITP
- Ludovic Henrio : Steering committee of the ICE workshop
10.1.2 Scientific events: selection
Member of the conference program committees
- Cyril Cohen : FroCoS 2025
- Gabriel Radanne : OCaml Workshop, FProper
- Ludovic Henrio : “Coordination” conference
10.1.3 Journal
Reviewer - reviewing activities
All permanent members of the team work as referees for various journals in their respective fields.
10.1.4 Invited talks
- Cyril Cohen gave an invited talk at Chalmers Workshop "Deep-Learning Models for Mathematics and Type Theory", in Göteborg (Sweden),
- Cyril Cohen gave an invited talk at Institut Pascal E-COST Action: EuroProofNet in Orsay,
- Cyril Cohen gave an invited talk at the Malinca ERC synergy grant kick-off meeting at IHP, Paris,
- Cyril Cohen gave an invited seminar at LaBRI in Bordeaux.
10.1.5 Leadership within the scientific community
-
Cyril Cohen
is
- 2025 - 2027: co-PI of the Leaning and Rocq'ing project, funded by the AI initiative AI for Math via a donation of Renaissance Philantropy (together with Guillaume Baudart, Marc Lelarge, Nicolas Tabareau). Total 890kUSD, including 2 budgeted post-doct.
- 2025 - 2028: french PI of theFormaSys Associate team (Japan PI: Reynald Affeldt) : 7 Inria members, 5 Japan members, 2 external members, 10800 EUR for travels in 2025,
- 2025 - 2026: co-PI of Inria Défi Liberabaci (with Martin Bodin), 7 EPI, 1 external partner,
- Rocq Zulip server administrator and code of conduct team member,
- Co-organizer of the monthly Proof Assistant Seminar at ENS de Lyon.
10.1.6 Scientific expertise
- Christophe Alias has been an examiner for the PhD defense of Clément Rossetti at Université de Strasbourg. PhD Advisor: Philippe Clauss, Inria CAMUS.
- Christophe Alias has been an external expert for the PhD evaluation committee (CSI) of Ugo Battiston, Raphaël Colin and Tom Hammer (Université de Strasbourg, Inria CAMUS).
- Cyril Cohen has been an examiner for the PhD defense of Théo Laurent at Université de Montpellier. PhD Advisors: Kenji Maillard and David Delahaye.
- Cyril Cohen has been an examiner for the PhD defense of Cécile Marcon at ISAE, Toulouse. PhD Advisors: Xavier THIRIOUX, Célia PICARD and Cyril Allignol.
10.1.7 Research administration
- Ludovic Henrio : Membre de l'équipe de direction du LIP, correspondant local PIQ, codirection de l'équipe CASH, membre du conseil de laboratoire du LIP, responsable du GT CLAP du GDR GPL.
10.2 Teaching - Supervision - Juries - Educational and pedagogical outreach
Licence
- Christophe Alias : "Compilation", INSA CVL 3A, cours+TD, 27h ETD. Oral examiner for the "second concours de l'ENS de Lyon". Grading and exam designing for X/ENS competitive exam.
- Matthieu Moy : “Référent pédagogique”, supervising 100 students/year; “Programmation web”, L3 UCBL, 19h; “Projet Informatique”, L3 UCBL, 9.5h.
- Etienne Parent : “Algorithmique, Programmation et Structures de données”, L2 UCBL, 24h TP ; “Architecture”, L2 UCBL, 18h TP.
- Yannick Zakowski : organisation du "Séminaire du département d'informatique" L3 ENS
Master 1
- Christophe Alias : "Optimisation des applications embarquées", INSA CVL 4A, cours+TD, 27h ETD.
- Christophe Alias and Emma Nardino : "Compilation", Préparation à l'agrégation d'informatique, ENS-Lyon, 10h cours + 10h TD.
- Cyril Cohen : "Proofs and Programs" (PP), M1 ENS de Lyon, Master Informatique Fondamentale, 4h CM + 14h TD.
- Matthieu Moy : “Compilation et traduction des programmes”, M1 UCBL, responsible, 31h; “Gestion de projet et génie logiciel”, M1 UCBL, responsible, 32h; “Projet pour l'Orientation en Master”, M1 UCBL, 2 students supervised.
- Gabriel Radanne , Ludovic Henrio and Emma Nardino : "Compilation and Analysis" (CAP), ENS-Lyon, Master d'Informatique Fondamentale, cours, 48h CM + 28h TD, 64h ETD.
10.3 Popularization
10.3.1 Participation in Live events
- Like every year, Matthieu Moy participated in a Declics meeting to present the research-related jobs to high-school pupils.
- Christophe Alias has been involved in the organization of "Journée Filles, Maths et Informatique" at ENS de Lyon.
11 Scientific production
11.1 Major publications
- 1 inproceedingsData-Aware Process Networks.CC 2021 - 30th ACM SIGPLAN International Conference on Compiler ConstructionVirtual, South KoreaACMMarch 2021, 1-11HALDOI
- 2 inproceedingsBit-Stealing Made Legal: Compilation for Custom Memory Representations Of Algebraic Data Types.Proceedings of the ACM on Programming LanguagesICFP 2023ICFPSeattle (USA), United StatesSeptember 2023HALDOIback to text
- 3 articleAvoiding Signature Avoidance in ML Modules with Zippers.Proceedings of the ACM on Programming LanguagesPOPL9January 2025HALDOI
- 4 articleChoice Trees: Representing Nondeterministic, Recursive, and Impure Programs in Coq.Proceedings of the ACM on Programming LanguagesJanuary 2023, 1-31HALDOI
- 5 articleAn Optimised Flow for Futures: From Theory to Practice.The Art, Science, and Engineering of Programming61July 2021, 1-41HALDOI
- 6 articleLocally Abstract, Globally Concrete Semantics of Concurrent Programming Languages.ACM Transactions on Programming Languages and Systems (TOPLAS)461March 2024, 1 - 58HALDOI
- 7 inproceedingsGodot: All the Benefits of Implicit and Explicit Futures.ECOOP 2019 - 33rd European Conference on Object-Oriented ProgrammingLeibniz International Proceedings in Informatics (LIPIcs)London, United Kingdom2019, 1-28HAL
- 8 articleA Survey on Parallelism and Determinism.ACM Computing SurveysSeptember 2022HALDOI
- 9 articleProvably Fair Cooperative Scheduling.The Art, Science, and Engineering of Programming82October 2023HALDOI
- 10 inproceedingsA Transistor Level Relational Semantics for Electrical Rule Checking by SMT Solving.https://ieeexplore.ieee.org/document/10546537Design, Automation and Test in Europe ConferenceValencia, SpainIEEE2024, 1-6HALDOI
11.2 Publications of the year
International journals
International peer-reviewed conferences
Doctoral dissertations and habilitation theses
Reports & preprints
Other scientific publications
Software
11.3 Cited publications
- 32 articleInteraction Trees.Proceedings of the ACM on Programming Languages4POPL2020HALDOIback to text
- 33 articleModular, compositional, and executable formal semantics for LLVM IR.Proceedings of the ACM on Programming Languages5ICFPAugust 2021, 1-30HALDOIback to text