The aim of the Parsifal team is to develop and exploit *proof
theory* and *type theory* in the specification,
verification, and analysis of computational systems.

*Expertise*: the team conducts basic research in proof
theory and type theory. In particular, the team is developing
results that help with automated deduction and with the
manipulation and communication of formal proofs.

*Design*: based on experience with computational systems
and theoretical results, the team develops new logical principles,
new proof systems, and new theorem proving environments.

*Implementation*: the team builds prototype systems to
help validate basic research results.

*Examples*: the design and implementation efforts are
guided by examples of specification and verification problems.
These examples not only test the success of the tools but also
drive investigations into new principles and new areas of proof
theory and type theory.

The foundational work of the team focuses on *structural* and
*analytic* proof theory, *i.e.*, the study of formal
proofs as algebraic and combinatorial structures and the study of
proof systems as deductive and computational formalisms. The main
focus in recent years has been the study of the *sequent
calculus* and of the *deep inference* formalisms.

An important research question is how to reason about computational
specifications that are written in a *relational* style. To
this end, the team has been developing new approaches to dealing
with induction, co-induction, and generic quantification. A second
important question is of *canonicity* in deductive systems,
*i.e.*, when are two derivations “essentially the same”? This
crucial question is important not only for proof search, because it
gives an insight into the structure and an ability to manipulate the
proof search space, but also for the communication of *proof
objects* between different reasoning agents such as automated
theorem provers and proof checkers.

Important application areas currently include:

Meta-theoretic reasoning on functional programs, such as terms
in the

Reasoning about behaviors in systems with concurrency and
communication, such as the *etc.*

Combining interactive and automated reasoning methods for induction and co-induction

Verification of distributed, reactive, and real-time algorithms that are often specified using modal and temporal logics

Representing proofs as documents that can be printed, communicated, and checked by a wide range of computational logic systems.

Development of cost models for the evaluation of proofs and programs.

There are two broad approaches for computational specifications. In
the *computation as model* approach, computations are encoded as
mathematical structures containing nodes, transitions, and state.
Logic is used to *describe* these structures, that is, the
computations are used as models for logical expressions. Intensional
operators, such as the modals of temporal and dynamic logics or the
triples of Hoare logic, are often employed to express propositions
about the change in state.

The *computation as deduction* approach, in contrast, expresses
computations logically, using formulas, terms, types, and proofs as
computational elements. Unlike the model approach, general logical
apparatus such as cut-elimination or automated deduction becomes
directly applicable as tools for defining, analyzing, and animating
computations. Indeed, we can identify two main aspects of logical
specifications that have been very fruitful:

*Proof normalization*, which treats the state of a
computation as a proof term and computation as normalization of the
proof terms. General reduction principles such as

*Proof search*, which views the state of a computation as a
a structured collection of formulas, known as a *sequent*, and
proof search in a suitable sequent calculus as encoding the dynamics
of the computation. Logic programming is based on proof
search , and different proof search
strategies can be used to justify the design of new and different
logic programming languages .

While the distinction between these two aspects is somewhat informal, it helps to identify and classify different concerns that arise in computational semantics. For instance, confluence and termination of reductions are crucial considerations for normalization, while unification and strategies are important for search. A key challenge of computational logic is to find means of uniting or reorganizing these apparently disjoint concerns.

An important organizational principle is structural proof theory,
that is, the study of proofs as syntactic, algebraic and
combinatorial objects. Formal proofs often have equivalences in
their syntactic representations, leading to an important research
question about *canonicity* in proofs – when are two proofs
“essentially the same?” The syntactic equivalences can be used to
derive normal forms for proofs that illuminate not only the proofs
of a given formula, but also its entire proof search space. The
celebrated *focusing* theorem of
Andreoli identifies one such normal form
for derivations in the sequent calculus that has many important
consequences both for search and for computation. The combinatorial
structure of proofs can be further explored with the use of
*deep inference*; in particular, deep inference allows access
to simple and manifestly correct cut-elimination procedures with
precise complexity bounds.

Type theory is another important organizational principle, but most
popular type systems are generally designed for either search or for
normalization. To give some examples, the Coq
system that implements the Calculus of Inductive
Constructions (CIC) is designed to facilitate the expression of
computational features of proofs directly as executable functional
programs, but general proof search techniques for Coq are rather
primitive. In contrast, the Twelf system
that is based on the LF type theory (a subsystem of the CIC), is
based on relational specifications in canonical form (*i.e.*,
without redexes) for which there are sophisticated automated
reasoning systems such as meta-theoretic analysis tools, logic
programming engines, and inductive theorem provers. In recent years,
there has been a push towards combining search and normalization in
the same type-theoretic framework. The Beluga
system , for example, is an extension of
the LF type theory with a purely computational meta-framework where
operations on inductively defined LF objects can be expressed as
functional programs.

The Parsifal team investigates both the search and the normalization aspects of computational specifications using the concepts, results, and insights from proof theory and type theory.

The team has spent a number of years in designing a strong new logic that can be used to reason (inductively and co-inductively) on syntactic expressions containing bindings. This work is based on earlier work by McDowell, Miller, and Tiu , and on more recent work by Gacek, Miller, and Nadathur . The Parsifal team, along with our colleagues in Minneapolis, Canberra, Singapore, and Cachan, have been building two tools that exploit the novel features of this logic. These two systems are the following.

Abella, which is an interactive theorem prover for the full logic.

Bedwyr, which is a model checker for the “finite” part of the logic.

We have used these systems to provide formalize reasoning of a number
of complex formal systems, ranging from programming languages to the

Since 2014, the Abella system has been extended with a number of new features. A number of new significant examples have been implemented in Abella and an extensive tutorial for it has been written .

The team is developing a framework for defining the semantics of proof evidence. With this framework, implementers of theorem provers can output proof evidence in a format of their choice: they will only need to be able to formally define that evidence's semantics. With such semantics provided, proof checkers can then check alleged proofs for correctness. Thus, anyone who needs to trust proofs from various provers can put their energies into designing trustworthy checkers that can execute the semantic specification.

In order to provide our framework with the flexibility that this
ambitious plan requires, we have based our design on the most recent
advances within the theory of proofs. For a number of years, various
team members have been contributing to the design and theory of
*focused proof systems*
and we have
adopted such proof systems as the corner stone for our framework.

We have also been working for a number of years on the implementation of computational logic systems, involving, for example, both unification and backtracking search. As a result, we are also building an early and reference implementation of our semantic definitions.

Deep inference , is a novel methodology for presenting deductive systems. Unlike traditional formalisms like the sequent calculus, it allows rewriting of formulas deep inside arbitrary contexts. The new freedom for designing inference rules creates a richer proof theory. For example, for systems using deep inference, we have a greater variety of normal forms for proofs than in sequent calculus or natural deduction systems. Another advantage of deep inference systems is the close relationship to category-theoretic proof theory. Due to the deep inference design one can directly read off the morphism from the derivations. There is no need for a counter-intuitive translation.

The following research problems are investigated by members of the Parsifal team:

Find deep inference system for richer logics. This is necessary for making the proof theoretic results of deep inference accessible to applications as they are described in the previous sections of this report.

Investigate the possibility of focusing proofs in deep inference. As described before, focusing is a way to reduce the non-determinism in proof search. However, it is well investigated only for the sequent calculus. In order to apply deep inference in proof search, we need to develop a theory of focusing for deep inference.

*Proof nets* graph-like presentations of sequent calculus proofs such
that all "trivial rule permutations" are quotiented away. Ideally
the notion of proof net should be independent from any syntactic
formalism, but most notions of proof nets proposed in the past were
formulated in terms of their relation to the sequent calculus.
Consequently we could observe features like “boxes” and explicit
“contraction links”. The latter appeared not only in Girard's
proof nets for linear logic but also in
Robinson's proof nets for classical
logic. In this kind of proof nets every link in the net corresponds
to a rule application in the sequent calculus.

Only recently, due to the rise of deep inference, new kinds of proof
nets have been introduced that take the formula trees of the
conclusions and add additional “flow-graph” information (see e.g.,
leading to the notion of
*atomic flow* and . On one side, this
gives new insights in the essence of proofs and their normalization.
But on the other side, all the known correctness criteria are no
longer available.

*Combinatorial proofs* are another form
syntax-independent proof presentation which separates the
multiplicative from the additive behaviour of classical connectives.

The following research questions investigated by members of the Parsifal team:

Finding (for classical and intuitionistic logic) a notion of canonical proof presentation that is deductive, i.e., can effectively be used for doing proof search.

Studying the normalization of proofs using atomic flows and combinatorial proofs, as they simplify the normalization procedure for proofs in deep inference, and additionally allow to get new insights in the complexity of the normalization.

Studying the size of proofs in the combinatorial proof formalism.

In the *proof normalization* approach, computation is usually reformulated as the evaluation of functional programs, expressed as terms in a variation over the

Models like Turing machines or RAM rely on atomic computational steps and thus admit quite obvious cost models for time and space. The

Nonetheless, it turns out that the number of *weak evaluation* (i.e., reducing only

With the recent recruitment of Accattoli, the team's research has expanded in this direction. The topics under investigations are:

*Complexity of Abstract Machines*. Bounding and comparing the overhead of different abstract machines for different evaluation schemas (weak/strong call-by-name/value/need

*Reasonable Space Cost Models*. Essentially nothing is known about reasonable space cost models. It is known, however, that environment-based execution model—which are the mainstream technology for functional programs—do not provide an answer. We are exploring the use of the non-standard implementation models provided by Girard's Geometry of Interaction to address this question.

The Parsifal team studies the structure of mathematical proofs, in ways that often makes them more amenable to automated theorem proving – automatically searching the space of proof candidates for a statement to find an actual proof – or a counter-example.

(Due to fundamental computability limits, fully-automatic proving is only possible for simple statements, but this field has been making a lot of progress in recent years, and is in particular interested with the idea of generating verifiable evidence for the proofs that are found, which fits squarely within the expertise of Parsial.)

The team work on the structure of proofs also suggests ways that they could be presented to a user, edited and maintained, in particular in “proof assistants”, automated tool to assist the writing of mathematical proofs with automatic checking of their correctness.

Our work also gives insight on the structure and properties of programming languages. We can improve the design or implementation of programming languages, help programmers or language implementors reason about the correctness of the programs in a given language, or reason about the cost of execution of a program.

The journal Mathematical Structures in Computer Science published “A special issue on structural proof theory, automated reasoning and computation in celebration of Dale Miller’s 60th birthday” – volume 29, Special issue 8, September 2019.

Accattoli was invited speaker at the international conference FSCD 2019.

Functional Description: Abella is an interactive theorem prover for reasoning about computations given as relational specifications. Abella is particuarly well suited for reasoning about binding constructs.

Participants: Dale Miller, Gopalan Nadathur, Kaustuv Chaudhuri, Mary Southern, Matteo Cimini, Olivier Savary-Bélanger and Yuting Wang

Partner: Department of Computer Science and Engineering, University of Minnesota

Contact: Kaustuv Chaudhuri

*Bedwyr - A proof search approach to model checking*

Keyword: Model Checker

Functional Description: Bedwyr is a generalization of logic programming that allows model checking directly on syntactic expressions that possibly contain bindings. This system, written in OCaml, is a direct implementation of two recent advances in the theory of proof search.

It is possible to capture both finite success and finite failure in a sequent calculus. Proof search in such a proof system can capture both may and must behavior in operational semantics. Higher-order abstract syntax is directly supported using term-level lambda-binders, the nabla quantifier, higher-order pattern unification, and explicit substitutions. These features allow reasoning directly on expressions containing bound variables.

The distributed system comes with several example applications, including the finite pi-calculus (operational semantics, bisimulation, trace analyses, and modal logics), the spi-calculus (operational semantics), value-passing CCS, the lambda-calculus, winning strategies for games, and various other model checking problems.

Participants: Dale Miller, Quentin Heath and Roberto Blanco Martinez

Contact: Dale Miller

*Checkers - A proof verifier*

Keywords: Proof - Certification - Verification

Functional Description: Checkers is a tool in Lambda-prolog for the certification of proofs. Checkers consists of a kernel which is based on LKF and is based on the notion of ProofCert.

Participants: Giselle Machado Nogueira Reis, Marco Volpe and Tomer Libal

Contact: Tomer Libal

*Proof-Search factorY for Collaborative HEuristics*

Keyword: Automated theorem proving

Functional Description: Psyche is a modular platform for automated or interactive theorem proving, programmed in OCaml and built on an architecture (similar to LCF) where a trusted kernel interacts with plugins. The kernel offers an API of proof-search primitives, and plugins are programmed on top of the API to implement search strategies. This architecture is set up for pure logical reasoning as well as for theory-specific reasoning, for various theories.

Release Functional Description: It is now equipped with the machinery to handle quantifiers and quantifier-handling techniques. Concretely, it uses meta-variables to delay the instantiation of existential variables, and constraints on meta-variables are propagated through the various branches of the search-space, in a way that allows local backtracking. The kernel, of about 800 l.o.c., is purely functional.

Participants: Assia Mahboubi, Jean-Marc Notin and Stéphane Graham-Lengrand

Contact: Stéphane Graham-Lengrand

Functional Description: Mætning is an automated theorem prover for intuitionistic predicate logic that is designed to disprove non-theorems.

Contact: Kaustuv Chaudhuri

Keywords: Functional programming - Static typing - Compilation

Functional Description: The OCaml language is a functional programming language that combines safety with expressiveness through the use of a precise and flexible type system with automatic type inference. The OCaml system is a comprehensive implementation of this language, featuring two compilers (a bytecode compiler, for fast prototyping and interactive use, and a native-code compiler producing efficient machine code for x86, ARM, PowerPC and System Z), a debugger, a documentation generator, a compilation manager, a package manager, and many libraries contributed by the user community.

Participants: Damien Doligez, Xavier Leroy, Fabrice Le Fessant, Luc Maranget, Gabriel Scherer, Alain Frisch, Jacques Garrigue, Marc Shinwell, Jeremy Yallop and Leo White

Contact: Damien Doligez

URL: https://

We have been designing a new functional programming language, MLTS,
that uses the * $\lambda $-tree* syntax approach to encoding
bindings that appear within data structures
. In this setting, bindings never become
free nor escape their scope: instead, binders in data structures are
permitted to

In addition to the natural semantics for MLTS that we proposed in
2018, we also have a small-step operational semantics which gives in
particular a fine-grained description of the runtime behavior of the

When proof assistants and theorem provers implement the metatheory of
logical systems, they must deal with a range of syntactic expressions
(e.g., types, formulas, and proofs) that involve variable bindings.
Since most mature proof assistants do not have built-in methods to
treat bindings, they have been extended with various packages and
libraries that allow them to encode such syntax using, for example, De
Bruijn numerals. In the paper, , Miller
puts forward the argument that bindings are such an intimate aspect of
the structure of expressions that they should be accounted for
directly in the underlying programming language support for proof
assistants and not via packages and libraries. He presents an
approach to designing programming languages and proof assistants that
directly supports bindings in syntax. The roots of this approach can
be found in the *mobility* of binders between term-level
bindings, formula-level bindings (quantifiers), and proof-level
bindings (eigenvariables). In particular, the combination of Church's
approach to terms and formulas (found in his Simple Theory of Types)
and Gentzen's approach to proofs (found in his sequent calculus)
yields a framework for the interaction of bindings with a full range
of logical connectives and quantifiers. Miller also illustrates how
that framework provides a direct and semantically clean treatment of
computation and reasoning with syntax containing bindings.

The formal framework of *Foundational Proof Certificates* (FPC)
was developed in previous years within the Parsifal team. We continue
to push on their applications in a number of settings in computational
logic. In 2019, we developed two such new applications.

In order to apply FPCs to the conventional setting of classical logic theorem provers, the FPC setting needed to treat proof evidence containing Skolem functions. Using FPC directly meant that we needed to do such certification without using the mathematical concepts of model-theoretic semantics (i.e., preservation of satisfiability) and choice principles (i.e., epsilon terms). Instead, our proof checking kernel is an implementation of Gentzen’s sequent calculus, which directly supports quantifier alternation by using eigenvariables. In , we described deskolemization as a mapping from client-side terms, used in proofs generated by theorem provers, into kernel-side terms, used within our proof checking kernel. This mapping which associates skolemized terms to eigenvariables relies on using outer skolemization.

Property-based testing (PBT) is a technique for validating code
against an executable specification by automatically generating
test-data. In the paper , we presented a
proof-theoretical reconstruction of this style of testing for
relational specifications and employ FPCs to describe test generators.
We did this by presenting certain kinds of “proof outlines” that can
be used to describe various common generation strategies in the PBT
literature, ranging from random to exhaustive, including their
combination. We also address the shrinking of counterexamples as a
first step towards their explanation. Once generation is accomplished,
the testing phase boils down to a standard logic programming search.
We could also we lift our techniques to treat data structures
containing bindings using *-tree* syntax. The

Miller has been working in the area of logic programming and proof theory for more than three decades. Some of his historical reflections on how these two topics influenced each other are contained in the paper . While it is widely known that proof theory has been helpful in shaping the development of logic programming, particular of extensions to conventional Prolog, this paper also documents a few specific examples where logic programming influenced the development of some topics in proof theory.

We present Intuitionistic Combinatorial Proofs (ICPs), a concrete geometric semantics of intuitionistic logic based on the principles of classical combinatorial proofs. An ICP naturally factorizes into a linear fragment, a graphical abstraction of an IMLL proof net (an arena net), and a parallel contraction-weakening fragment (a skew fibration). ICPs relate to game semantics, and can be seen as a strategy in a Hyland-Ong arena, generalized from a tree-like to a dag-like strategy. Our first main result, Polynomial Full Completeness, is thatICPs as a semantics are complexity-aware: the translations to and from sequent calculus are size-preserving (up to a polynomial). By contrast, lambda-calculus and game semantics incur an exponential blowup. Our second main result, Local Canonicity, is that ICPs abstract fully and faithfully over the non-duplicating permutations of the sequent calculus. These results have been presented at the LICS 2019 conference .

The main part of a classical combinatorial proof is a skew fibration, which precisely captures the behavior of weakening and contraction. Relaxing the presence of these two rules leads to certain substructural logics and substructural proof theory. We investigated what happens if we replace the skew fibration by other kinds of graph homomorphism. This leads us to new logics and proof systems that we call combinatorial. This has been presented at the TABLEAUX 2019 conference .

In this work (presented at the WoLLIC 2019 conference ) we characterize classical combinatorial proofs which also represent valid proofs for relevant logic with and without the mingle axiom. Moreover, we extend our syntax in order to represent combinatorial proofs for the more restrictive framework of entailment logic.

In this work, we introduce the notion of expansion tree for linear logic. As in Miller's original work, we have a shallow reading of an expansion tree that corresponds to the conclusion of the proof, and a deep reading which is a formula that can be proved by propositional rules. We focus our attention to MLL2, and we also present a deep inference system for that logic. This allows us to give a syntactic proof to a version of Herbrand's theorem. This has been published in an special issue of MSCS .

In this paper we present a labelled sequent system for intuitionistic modal logics such that there is not only one, but two relation symbols appearing in sequents: one for the accessibility relation associated with the Kripke semantics for normal modal logics and one for the preorder relation associated with the Kripke semantics for intuitionistic logic. This puts our system in close correspondence with the standard birelational Kripke semantics for intuitionistic modal logics. As a consequence it can encompass a wider range of intuitionistic modal logics than existing labelled systems. We also show an internal cut elimination proof for our system .

This joint work with Giulio Guerrieri (Post-doc at Bath University) develops a multi type system for call-by-need evaluation of the

This joint work with Giulio Guerrieri (Post-doc at Bath University) studies a new compilation technique for functional programs, dubbed *crumbling* and resembling the transformation into administrative normal form of Flanagan, Sabry, Duba, and Felleisen. It is shown that it simplifies the design of abstract machines without altering the complexity of the overhead. Moreover, it smoothly scales up to open terms and it does not suffer of the slowdowns of administrative normal forms pointed out by Kennedy.

This joint work with Claudia Faggian (CNRS researcher at Paris Diderot) and Giulio Guerrieri (Post-doc at Bath University) refines a rewriting technique for proving factorization and normalization theorems for

This journal paper in collaboration with Giulio Guerrieri (Post-doc at Bath University) outlines a theory of abstract machines for the call-by-value

The OCaml Software Foundation (OCSF),

Gabriel Scherer serves as the director of the foundation.

Nomadic Labs, a Paris-based company, has implemented the Tezos blockchain and cryptocurrency entirely in OCaml. This year, Nomadic Labs and Inria have signed a framework agreement (“contrat-cadre”) that allows Nomadic Labs to fund multiple research efforts carried out by Inria groups. Within this framework, we participate to two 3-year grants, in collaboration with the Cambium team at Inria Paris:

“Évolution d’OCaml”. This grant is intended to fund a number of improvements to OCaml, including the addition of new features and a possible re-design of the OCaml type-checker.

“Maintenance d’OCaml”. This grant is intended to fund the day-to-day maintenance of OCaml as well as the considerable work involved in managing the release cycle.

Gabriel Scherer obtained funding from the Région Île-de-France to hire a post-doc, Luc Pellissier, to work on canonical representation of programs (linking proof theory and category-theory approaches), in collaboration with Adrien Guatto in IRIF (Université Paris 7).

COCA HOLA: Cost Models for Complexity Analyses of Higher-Order Languages, coordinated by B. Accattoli, 2016–2019.

FISP: The Fine Structure of Formal Proof Systems and their Computational Interpretations, coordinated by Lutz Straßburger in collaboration with Université Paris 7, Universität Innsbruck and TU Wien, 2016–2019.

UPScale: Universality of Proofs in SaCLay, a Working Group of LabEx DigiCosme, organized by Chantal Keller (LRI) with regular participation from Parsifal members and a post-doc co-supervision.

Claudio Sacerdoti Coen (Universita di Bologna, Italy) spent a month visiting Beniamino Accattoli thanks to funding for short-term international visits.

Dale Miller is currently General Chair for the ACM/IEEE Symposium on Logic in Computer Science (LICS).

Dale Miller is member of the Steering Committee for CPP, FSCD, and LFMTP and is a member of the Executive Committee of the ACM Special Interest Group on Logic and Compuation (SIGLOG).

Gabriel Scherer is part of the Steering Committee of the ML Family Workshop and the OCaml Workshop.

Dale Miller was program committee co-chair for the workshop on Logical Frameworks and Meta Languages: Theory and Practice (LFMTP), 2019, Vancouver, Canada.

Gabriel Scherer: JFLA 2020.

Beniamino Accattoli: LSFA 2019.

Dale Miller is a PC member for the 10th International Joint Conference on Automated Reasoning (IJCAR-2020), the 23rd International Conference on Logic for Programming, Artificial Intelligence and Reasoning (LPAR-23), and the Workshop on Trends, Extensions, Applications and Semantics of Logic Programming (TEASE-LP).

Gabriel Scherer: POPL 2020, ESOP 2020.

Lutz Straßburger: FoSSaCS 2020, CSL 2020, TABLEAUX 2019, WoLLIC 2019, LICS 2019.

Beniamino Accattoli: FoSSaCS 2020, POPL 2020, ICALP 2019, ICTAC 2019, PPDP 2019, FSCD 2019, CSL 2019, LSFA 2019.

Dale Miller is on the editorial board of the Journal of Automated Reasoning (Springer) and the Jounral of Applied Logic (Elsevier). He has also been an editor for a special issue of FSCD 2017 for Logical Methods in Computer Science.

Lutz Straßburger: APAL, ToCL, BSL, LMCS.

Beniamino Accattoli: LMCS, TCS.

Dale Miller has served on the evaluation committee for the EATCS Distinguished Dissertation Award and the EACSL Ackermann Award. He was also the Chair of the Herbrand Award Committee of the Association for Automated Reasoning.

Beniamino Accattoli has been invited speaker at FSCD 2019.

Dale Miller has been an invited speaker at the Workshop on Proof Theory for Automated Deduction, Automated Deduction for Proof Theory (23-25 October 2019, Funchal, Madeira) and the Third Tübingen Conference on Proof-Theoretic Semantics, 27-30 March 2019.

Lutz Straßburger: reviewer for the Israel Science Foundation.

Dale Miller has been a member of an international review panel for the Distinguished Professor Grant at the Swedish Research Council.

Gabriel Scherer: reviewer for ANR.

Licence : G. Scherer, “*Introduction á la programmation fonctionnelle*”,
50h, L1, Paris 8 (Vincennes - Saint Denis), France

Master: B. Accattoli, “*Logique linéaire et paradigmes logiques du calcul*”,
18h, M2, Master Parisien de Recherche en Informatique (MPRI), France.

Master: D. Miller, “*Logique linéaire et paradigmes logiques du calcul*”,
18h, M2, Master Parisien de Recherche en Informatique (MPRI), France.

Summer School: G. Scherer, “*Programmation fonctionnelle en OCaml*”,
12h, public d'ingénieurs de recherche, formation ANF (CNRS), France

Summer School: L. Straßburger: “*Introduction to Deep
Inference*”, 10h, ESSLLI 2020, Riga, Latvia

Summer School: B. Accattoli, “* $\lambda $-Calculus and Reasonable Cost Models*”,
15h, Escuela de Ciencia Informaticas (ECI 2019), Buenos Aires, Argentina.

PhD in progress: Marianela Morales, “Combinatorial Proof Theory for Modal Logic”, 1/10/2019, Lutz Straßburger.

PhD in progress: Maico Leberle, “Call-by-need and Reasonable Cost Models”, Beniamino Accattoli.

PhD completed: Ulysse Gérard, “Computing with relations, functions, and bindings”, 18 October 2019, Ecole Doctorale de l’Institut Polytechnique de Paris, advised by Dale Miller.

PhD in progress: Matteo Manighetti, “Structural proof theory for induction in linear logic”, advised by Dale Miller since 1/10/2017.

PhD in progress: Marianela Morales, “Combinatorial Proof Theory for Modal Logic”, 1/10/2019, Lutz Straßburger

Dale Miller was a reportor for the PhD thesis of Aurore Alcolei (ENS Lyon, 17 October 2019).

G. Scherer and M. Manighetti participated the “Fête de la Science” exhibit at Inria Saclay on the whole day of October 11th, 2019.

G. Scherer presented the research domain of certified programming to an audience of computer security professionals at the “Pass the Salt” conference in Lille, on Wednesday July 3rd.