The $\lambda$-calculus, defined by Church  42, is a remarkably succinct model of computation that is defined via only three constructions (abstraction of a program with respect to one of its parameters, reference to such a parameter, application of a program to an argument) and one reduction rule (substitution of the formal parameter of a program by its effective argument). The $\lambda$-calculus, which is Turing-complete, i.e. which has the same expressiveness as a Turing machine (there is for instance an encoding of numbers as functions in $\lambda$-calculus), comes with two possible semantics referred to as call-by-name and call-by-value evaluations. Of these two semantics, the first one, which is the simplest to characterise, has been deeply studied in the last decades  26.

To explain the Curry-Howard correspondence, it is important to distinguish between intuitionistic and classical logic: following Brouwer at the beginning of the 20th century, classical logic is a logic that accepts the use of reasoning by contradiction while intuitionistic logic proscribes it. Then, Howard's observation is that the proofs of the intuitionistic natural deduction formalism exactly coincide with programs in the (simply typed) $\lambda$-calculus.

A major achievement has been accomplished by Martin-Löf who designed in 1971 a formalism, referred to as modern type theory, that was both a logical system and a (typed) programming language  68.

In 1985, Coquand and Huet  45, 43 in the Formel team of INRIA-Rocquencourt explored an alternative approach based on Girard-Reynolds' system $F$  55, 72. This formalism, called the Calculus of Constructions, served as logical foundation of the first implementation of Coq in 1984. Coq was called CoC at this time.

The first public release of CoC dates back to 1989. The same project-team developed the programming language Caml (nowadays called OCaml and coordinated by the Gallium team) that provided the expressive and powerful concept of algebraic data types (a paragon of it being the type of lists). In CoC, it was possible to simulate algebraic data types, but only through a not-so-natural not-so-convenient encoding.

In 1989, Coquand and Paulin  44 designed an extension of the Calculus of Constructions with a generalisation of algebraic types called inductive types, leading to the Calculus of Inductive Constructions (CIC) that started to serve as a new foundation for the Coq system. This new system, which got its current definitive name Coq, was released in 1991.

In practice, the Calculus of Inductive Constructions derives its strength from being both a logic powerful enough to formalise all common mathematics (as set theory is) and an expressive richly-typed functional programming language (like ML but with a richer type system, no effects and no non-terminating functions).

The architecture adopts the so-called de Bruijn principle: the well-delimited kernel of Coq ensures the correctness of the proofs validated by the system. The kernel is rather stable with modifications tied to the evolution of the underlying Calculus of Inductive Constructions formalism. The kernel includes an interpreter of the programs expressible in the CIC and this interpreter exists in two flavours: a customisable lazy evaluation machine written in OCaml and a call-by-value bytecode interpreter written in C dedicated to efficient computations. The kernel also provides a module system.

The concrete user language of Coq, called Gallina, is a high-level language built on top of the CIC. It includes a type inference algorithm, definitions by complex pattern-matching, implicit arguments, mathematical notations and various other high-level language features. This high-level language serves both for the development of programs and for the formalisation of mathematical theories. Coq also provides a large set of commands. Gallina and the commands together forms the Vernacular language of Coq.

The standard library is written in the vernacular language of Coq. There are libraries for various arithmetical structures and various implementations of numbers (Peano numbers, implementation of $\mathbb{N}$, $\mathbb{Z}$, $\mathbb{Q}$ with binary digits, implementation of $\mathbb{N}$, $\mathbb{Z}$, $\mathbb{Q}$ using machine words, axiomatisation of $ℝ$). There are libraries for lists, list of a specified length, sorts, and for various implementations of finite maps and finite sets. There are libraries on relations, sets, orders.

The tactics are the methods available to conduct proofs. This includes the basic inference rules of the CIC, various advanced higher level inference rules and all the automation tactics. Regarding automation, there are tactics for solving systems of equations, for simplifying ring or field expressions, for arbitrary proof search, for semi-decidability of first-order logic and so on. There is also a powerful and popular untyped scripting language for combining tactics into more complex tactics.

Note that all tactics of Coq produce proof certificates that are checked by the kernel of Coq. As a consequence, possible bugs in proof methods do not hinder the confidence in the correctness of the Coq checker. Note also that the CIC being a programming language, tactics can have their core written (and certified) in the own language of Coq if needed.

Extraction is a component of Coq that maps programs (or even computational proofs) of the CIC to functional programs (in OCaml, Scheme or Haskell). Especially, a program certified by Coq can further be extracted to a program of a full-fledged programming language then benefiting of the efficient compilation, linking tools, profiling tools, ... of the target language.

Coq is a feature-rich system and requires extensive training in order to be used proficiently; current documentation includes the reference manual, the reference for the standard library, as well as tutorials, and related tooling [sphinx plugins, coqdoc]. The jsCoq tool allows writing interactive web pages were Coq programs can be embedded and executed.

Coq is used in large-scale proof developments, and provides users miscellaneous tooling to help with them: the coq_makefile and Dune build systems help with incremental proof-checking; the Coq OPAM repository contains a package index for most Coq developments; the CoqIDE, ProofGeneral, jsCoq, and VSCoq user interfaces are environments for proof writing; and the Coq's API does allow users to extend the system in many important ways. Among the current extensions we have QuickChik, a tool for property-based testing; STMCoq and CoqHammer integrating Coq with automated solvers; ParamCoq, providing automatic derivation of parametricity principles; MetaCoq for metaprogramming; Equations for dependently-typed programming; SerAPI, for data-centric applications; etc... This also includes the main open Coq repository living at Github.

We will work for this in a proactive way, in close collaboration with IRIF and IMJ-PRG gathering motivated mathematicians and computer scientists willing to formalise the mathematics they teach at the University, or on which they conduct their research work. Indeed, we aim at formalising classical mathematics curricula, pieces of contemporary mathematics as well as mathematical tools implemented in theoretical computer science. We will draw inspiration from the usually heuristic practice of mathematics, aiming to make the writing and reading of Coq documents altogether more intuitive, more straightforward and more flexible. This software development and mechanisation work will be combined with a study of the linguistic structure of mathematical documents, in collaboration with Philippe de Groote (Sémagramme): we think that there is a need to better understand the linguistic structures at work in the daily life of a mathematician and their formal nature.

More specifically, among the subjects of formalisation of mathematics we plan to carry in the team, three in particular should be mentioned:

This research topic will therefore be based at the same time on a formalisation activity internal to the team, and on a long-term work of animation and construction of a scientific community involved in formalisation. We plan to contribute to the Coq training of our maths and CS colleagues (from PhD students to post-docs and those holding a permanent position), and not only grad students as it is more commonly the case, in particular through the organisation of regular sessions of working groups dedicated to helping colleagues in their formalisation tasks and by considering the opportunity to set up thematic schools in collaboration with the other teams of the institute contributing to Coq. A medium-term objective could be to achieve that some pure mathematics modules are based directly on formalised content and that some mathematics tutorials take the form of Coq exercise sessions, starting from existing works on Coq  29, 70, 41. This will require to develop close collaborations with the different communities of other proof assistants, especially those designed to be well-adapted to the formalisation of mathematics (Lean, Isabelle and Agda in particular). Understanding linguistic aspects of mathematical proofs will be a key to the success of our project.

Formalising inevitably leads to a shift of perspective on what a mathematical proof is. From a mathematical standpoint, it is conventional, even if developments are emerging, to be satisfied of the mere possibility of a formalisation (which is never even sketched out) typically in the set-theoretical formalism, and to focus on the construction of a natural language discourse that is precise enough to convince the reader. From the proof assistant standpoint, the seminal vision which initially aimed only at making effective this virtuality, tends to evolve. New lines of communication and convergence are emerging: a proof is no longer strictly made up of logical inference rules, such as introducing or eliminating a connective, but it is made of more abstract entities such as the use of a lemma, the replacement of equals by equals, reasoning by induction, simplifying a polynomial expression, decomposing a formula in atoms, etc. With the arrival of a new generation of interactive proof engines  77, 27, a proof is no longer seen strictly as a tree derivation, but as a graph whose nodes can be refined with a reasonable degree of freedom; moreover, the order in which these transformations are applied interactively appears in the “incremental” format of the machine maths document. This is in line with the historical evolution of proof methods in order to escape from the “low level” of logic and get closer to more abstract conceptual levels used by humans. Our investigations will follow this line as we plan to analyse the linguistic structure of mathematical texts, with the ambition to develop the levels of abstraction which would eventually allow a direct formal understanding of a mathematical text at the level of mathematical discourse in which it is expressed. Examples of the sorts of linguistic structures we plan to analyse are “reasoning by analogy”, reasoning modulo isomorphism, or even modulo inclusion, and of course reasoning modulo general equational theories in general.

On this natural (mathematical) language processing part, we plan a collaboration with Philippe de Groote of the Sémagramme team (Inria Nancy & Loria), to identify the necessary structures for a flexible formalisation of vernacular mathematical proofs in order to implement this linguistic structure within Coq, procedural and discursive in nature rather than tree-like as described above. One of the objectives will be to be able to formalise in a more transparent and direct way mathematical texts, such Bourbaki's Éléments de mathématiques.

Regarding the design and development of a general mathematical library, it is undoubtedly too early to describe the directions we will take, but we have some ongoing discussions with Assia Mahboubi (Gallinette), Yves Bertot and Cyril Cohen (Scalp) around these essential questions. We also wish to develop the team's scientific interactions with Michael Soegtrop (Apple) and we closely follow his projects on proving algorithms of symbolic computing, around constructive reals and the formal integrator Rubi. We are also in contact with mathematicians from IMJ-PRG, and in particular with Antoine Chambert-Loir, who expressed a keen interest in formalisation.

We want to develop fruitful discussions with the communities of other proof assistants, such as Agda, Isabelle or Lean.

Like ordinary categories, higher-dimensional categorical structures originate in algebraic topology. Indeed, $\infty$-groupoids have been initially considered as a unified point of view for all the information contained in the homotopy groups of a topological space $X$: the fundamental $\infty$-groupoid$\Pi \left(X\right)$ of $X$ contains the elements of $X$ as 0-dimensional cells, continuous paths in $X$ as 1-cells, homotopies between continuous paths as 2-cells, and so on. This point of view translates a topological problem (to determine if two given spaces $X$ and $Y$ are homotopically equivalent) into an algebraic problem (to determine if the fundamental groupoids $\Pi \left(X\right)$ and $\Pi \left(Y\right)$ are equivalent).

In the last decades, the importance of higher-dimensional categories has grown fast, mainly with the new trend of categorification that currently touches algebra and the surrounding fields of mathematics. Categorification is an informal process that consists in the study of higher-dimensional versions of known algebraic objects (such as higher Lie algebras in mathematical physics 24) and/or of “weakened” versions of those objects, where equations hold only up to suitable equivalences (such as weak actions of monoids and groups in representation theory 49).

The categorification process has also reached logic, with the introduction of homotopy type theory. After a preliminary result that had identified categorical structures in type theory 64, it has been observed recently that the so-called “identity types” are naturally equiped with a structure of $\infty$-groupoid: the 1-cells are the proofs of equality, the 2-cells are the proofs of equality between proofs of equality, and so on. The striking resemblance with the fundamental $\infty$-groupoid of a topological space led to the conjecture that homotopy type theory could serve as a replacement of set theory as a foundational language for different fields of mathematics, and homotopical algebra in particular.

Higher-dimensional categories are algebraic structures that contain, in essence, computational aspects. This has been recognised by Street 78, and independently by Burroni 36, when they have introduced the concept of computad or polygraph as combinatorial descriptions of higher categories. Those are directed presentations of higher-dimensional categories, generalising word and term rewriting systems.

In the recent years, the algebraic structure of polygraph has led to a new theory of rewriting, called higher-dimensional rewriting, as a unifying point of view for usual rewriting paradigms, namely abstract, word and term rewriting 66, 67, 59, 60, and beyond: Petri nets 62 and formal proofs of classical and linear logic have been expressed in this framework 61. Higher-dimensional rewriting has developed its own methods to analyse computational properties of polygraphs, using in particular algebraic tools such as derivations to prove termination, which in turn led to new tools for complexity analysis 32.