Merge PR #9133: Move README-V1-V5 to credits chapter

Reviewed-by: cpitclaudel

5 files changed, 493 insertions, 420 deletions

diff --git a/dev/README.md b/dev/README.md
index d9fdd230d3..9761f7b96f 100644
--- a/dev/README.md
+++ b/dev/README.md
@@ -25,7 +25,6 @@
 | [`dev/doc/universes.txt`](doc/universes.txt) |  Help for debugging universes |
 | [`dev/doc/extensions.txt`](doc/extensions.txt) | Some help about TACTIC EXTEND |
 | [`dev/doc/perf-analysis`](doc/perf-analysis)|  Analysis of perfs measured on the compilation of user contribs |
-| [`dev/doc/cic.dtd`](doc/cic.dtd) | Official dtd of the calc. of ind. constr. for im/ex-portation |
 | [`dev/doc/econstr.md`](doc/econstr.md) | Describes `Econstr`, implementation of treatment of `evar` in the engine |
 | [`dev/doc/primproj.md`](doc/primproj.md) | Describes primitive projections |
 | [`dev/doc/proof-engine.md`](doc/proof-engine.md) | Tutorial on new proof engine |
diff --git a/dev/doc/README-V1-V5.asciidoc b/dev/doc/README-V1-V5.asciidoc
deleted file mode 100644
index 631fb92c97..0000000000
--- a/dev/doc/README-V1-V5.asciidoc
+++ /dev/null
@@ -1,378 +0,0 @@
-Notes on the prehistory of Coq
-==============================
-:author:  Thierry Coquand, Gérard Huet & Christine Paulin-Mohring
-:revdate: September 2015
-:toc:
-:toc-placement: preamble
-:toclevels: 1
-:showtitle:
-
-
-This document is a copy within the Coq archive of a document written
-in September 2015 by Gérard Huet, Thierry Coquand and Christine Paulin
-to accompany their public release of the archive of versions 1.10 to 6.2
-of Coq and of its CONSTR ancestor. CONSTR, then Coq, was designed and
-implemented in the Formel team, joint between the INRIA Rocquencourt
-laboratory and the Ecole Normale Supérieure of Paris, from 1984
-onwards.
-
-Version 1
----------
-
-This software is a prototype type-checker for a higher-order logical
-formalism known as the Theory of Constructions, presented in his PhD
-thesis by Thierry Coquand, with influences from Girard's system F and
-de Bruijn's Automath.  The metamathematical analysis of the system is
-the PhD work of Thierry Coquand. The software is mostly the work of
-Gérard Huet.  Most of the mathematical examples verified with the
-software are due to Thierry Coquand.
-
-The programming language of the CONSTR software (as it was called at
-the time) was a version of ML adapted from the Edinburgh LCF system
-and running on a LISP backend. The main improvements from the original
-LCF ML were that ML was compiled rather than interpreted (Gérard Huet
-building on the original translator by Lockwood Morris), and that it
-was enriched by recursively defined types (work of Guy
-Cousineau). This ancestor of CAML was used and improved by Larry
-Paulson for his implementation of Cambridge LCF.
-
-Software developments of this prototype occurred from late 1983 to
-early 1985.
-
-Version 1.10 was frozen on December 22nd 1984. It is the version used
-for the examples in Thierry Coquand's thesis, defended on January 31st
-1985.  There was a unique binding operator, used both for universal
-quantification (dependent product) at the level of types and
-functional abstraction (λ) at the level of terms/proofs, in the manner
-of Automath. Substitution (λ-reduction) was implemented using de
-Bruijn's indexes.
-
-Version 1.11 was frozen on February 19th, 1985. It is the version used
-for the examples in the paper: Th. Coquand, G. Huet. __Constructions: A
-Higher Order Proof System for Mechanizing Mathematics__ <<CH85>>.
-
-Christine Paulin joined the team at this point, for her DEA research
-internship.  In her DEA memoir (August 1985) she presents developments
-for the _lambo_ function – _lambo(f)(n)_ computes the minimal _m_ such
-that _f(m)_ is greater than _n_, for _f_ an increasing integer
-function, a challenge for constructive mathematics. She also encoded
-the majority voting algorithm of Boyer and Moore.
-
-Version 2
----------
-
-The formal system, now renamed as the _Calculus of Constructions_, was
-presented with a proof of consistency and comparisons with proof
-systems of Per Martin Löf, Girard, and the Automath family of N. de
-Bruijn, in the paper: T. Coquand and G. Huet. __The Calculus of
-Constructions__ <<CH88>>.
-
-An abstraction of the software design, in the form of an abstract
-machine for proof checking, and a fuller sequence of mathematical
-developments was presented in: Th. Coquand, G. Huet. __Concepts
-Mathématiques et Informatiques Formalisés dans le Calcul des
-Constructions__<<CH87>>.
-
-Version 2.8 was frozen on December 16th, 1985, and served for
-developing the exemples in the above papers.
-
-This calculus was then enriched in version 2.9 with a cumulative
-hierarchy of universes. Universe levels were initially explicit
-natural numbers.  Another improvement was the possibility of automatic
-synthesis of implicit type arguments, relieving the user of tedious
-redundant declarations.
-
-Christine Paulin wrote an article __Algorithm development in the
-Calculus of Constructions__ <<P86>>. Besides _lambo_ and _majority_,
-she presents quicksort and a text formatting algorithm.
-
-Version 2.13 of the Calculus of Constructions with universes was
-frozen on June 25th, 1986.
-
-A synthetic presentation of type theory along constructive lines with
-ML algorithms was given by Gérard Huet in his May 1986 CMU course
-notes _Formal Structures for Computation and Deduction_. Its chapter
-_Induction and Recursion in the Theory of Constructions_ was presented
-as an invited paper at the Joint Conference on Theory and Practice of
-Software Development TAPSOFT’87 at Pise in March 1987, and published
-as __Induction Principles Formalized in the Calculus of
-Constructions__ <<H88>>.
-
-Version 3
----------
-
-This version saw the beginning of proof automation, with a search
-algorithm inspired from PROLOG and the applicative logic programming
-programs of the course notes _Formal structures for computation and
-deduction_.  The search algorithm was implemented in ML by Thierry
-Coquand.  The proof system could thus be used in two modes: proof
-verification and proof synthesis, with tactics such as `AUTO`.
-
-The implementation language was now called CAML, for Categorical
-Abstract Machine Language. It used as backend the LLM3 virtual machine
-of Le Lisp by Jérôme Chailloux. The main developers of CAML were
-Michel Mauny, Ascander Suarez and Pierre Weis.
-
-V3.1 was started in the summer of 1986, V3.2 was frozen at the end of
-November 1986. V3.4 was developed in the first half of 1987.
-
-Thierry Coquand held a post-doctoral position in Cambrige University
-in 1986-87, where he developed a variant implementation in SML, with
-which he wrote some developments on fixpoints in Scott's domains.
-
-Version 4
----------
-
-This version saw the beginning of program extraction from proofs, with
-two varieties of the type `Prop` of propositions, indicating
-constructive intent.  The proof extraction algorithms were implemented
-by Christine Paulin-Mohring.
-
-V4.1 was frozen on July 24th, 1987. It had a first identified library
-of mathematical developments (directory exemples), with libraries
-Logic (containing impredicative encodings of intuitionistic logic and
-algebraic primitives for booleans, natural numbers and list), `Peano`
-developing second-order Peano arithmetic, `Arith` defining addition,
-multiplication, euclidean division and factorial. Typical developments
-were the Knaster-Tarski theorem and Newman's lemma from rewriting
-theory.
-
-V4.2 was a joint development of a team consisting of Thierry Coquand,
-Gérard Huet and Christine Paulin-Mohring. A file V4.2.log records the
-log of changes.  It was frozen on September 1987 as the last version
-implemented in CAML 2.3, and V4.3 followed on CAML 2.5, a more stable
-development system.
-
-V4.3 saw the first top-level of the system. Instead of evaluating
-explicit quotations, the user could develop his mathematics in a
-high-level language called the mathematical vernacular (following
-Automath terminology).  The user could develop files in the vernacular
-notation (with .v extension) which were now separate from the `ml`
-sources of the implementation.  Gilles Dowek joined the team to
-develop the vernacular language as his DEA internship research.
-
-A notion of sticky constant was introduced, in order to keep names of
-lemmas when local hypotheses of proofs were discharged. This gave a
-notion of global mathematical environment with local sections.
-
-Another significant practical change was that the system, originally
-developped on the VAX central computer of our lab, was transferred on
-SUN personal workstations, allowing a level of distributed
-development.  The extraction algorithm was modified, with three
-annotations `Pos`, `Null` and `Typ` decorating the sorts `Prop` and
-`Type`.
-
-Version 4.3 was frozen at the end of November 1987, and was
-distributed to an early community of users (among those were Hugo
-Herbelin and Loic Colson).
-
-V4.4 saw the first version of (encoded) inductive types.  Now natural
-numbers could be defined as:
-
-[source, coq]
-Inductive NAT : Prop = O : NAT | Succ : NAT->NAT.
-
-These inductive types were encoded impredicatively in the calculus,
-using a subsystem _rec_ due to Christine Paulin.  V4.4 was frozen on
-March 6th 1988.
-
-Version 4.5 was the first one to support inductive types and program
-extraction.  Its banner was _Calcul des Constructions avec
-Réalisations et Synthèse_.  The vernacular language was enriched to
-accommodate extraction commands.
-
-The verification engine design was presented as: G. Huet. _The
-Constructive Engine_. Version 4.5. Invited Conference, 2nd European
-Symposium on Programming, Nancy, March 88.  The final paper,
-describing the V4.9 implementation, appeared in: A perspective in
-Theoretical Computer Science, Commemorative Volume in memory of Gift
-Siromoney, Ed. R. Narasimhan, World Scientific Publishing, 1989.
-
-Version 4.5 was demonstrated in June 1988 at the YoP Institute on
-Logical Foundations of Functional Programming organized by Gérard Huet
-at Austin, Texas.
-
-Version 4.6 was started during the summer of 1988. Its main
-improvement was the complete rehaul of the proof synthesis engine by
-Thierry Coquand, with a tree structure of goals.
-
-Its source code was communicated to Randy Pollack on September 2nd
-1988.  It evolved progressively into LEGO, proof system for Luo's
-formalism of Extended Calculus of Constructions.
-
-The discharge tactic was modified by Gérard Huet to allow for
-inter-dependencies in discharged lemmas. Christine Paulin improved the
-inductive definition scheme in order to accommodate predicates of any
-arity.
-
-Version 4.7 was started on September 6th, 1988.
-
-This version starts exploiting the CAML notion of module in order to
-improve the modularity of the implementation. Now the term verifier is
-identified as a proper module Machine, which the structure of its
-internal data structures being hidden and thus accessible only through
-the legitimate operations.  This machine (the constructive engine) was
-the trusted core of the implementation. The proof synthesis mechanism
-was a separate proof term generator. Once a complete proof term was
-synthesized with the help of tactics, it was entirely re-checked by
-the engine. Thus there was no need to certify the tactics, and the
-system took advantage of this fact by having tactics ignore the
-universe levels, universe consistency check being relegated to the
-final type-checking pass. This induced a certain puzzlement in early
-users who saw, after a successful proof search, their `QED` followed
-by silence, followed by a failure message due to a universe
-inconsistency…
-
-The set of examples comprise set theory experiments by Hugo Herbelin,
-and notably the Schroeder-Bernstein theorem.
-
-Version 4.8, started on October 8th, 1988, saw a major
-re-implementation of the abstract syntax type `constr`, separating
-variables of the formalism and metavariables denoting incomplete terms
-managed by the search mechanism.  A notion of level (with three values
-`TYPE`, `OBJECT` and `PROOF`) is made explicit and a type judgement
-clarifies the constructions, whose implementation is now fully
-explicit. Structural equality is speeded up by using pointer equality,
-yielding spectacular improvements. Thierry Coquand adapts the proof
-synthesis to the new representation, and simplifies pattern matching
-to first-order predicate calculus matching, with important performance
-gain.
-
-A new representation of the universe hierarchy is then defined by
-Gérard Huet.  Universe levels are now implemented implicitly, through
-a hidden graph of abstract levels constrained with an order relation.
-Checking acyclicity of the graph insures well-foundedness of the
-ordering, and thus consistency. This was documented in a memo _Adding
-Type:Type to the Calculus of Constructions_ which was never published.
-
-The development version is released as a stable 4.8 at the end of
-1988.
-
-Version 4.9 is released on March 1st 1989, with the new ``elastic''
-universe hierarchy.
-
-The spring of 1989 saw the first attempt at documenting the system
-usage, with a number of papers describing the formalism:
-
-- _Metamathematical Investigations of a Calculus of Constructions_, by
-  Thierry Coquand <<C90>>,
-- _Inductive definitions in the Calculus of Constructions_, by
-   Christine Paulin-Mohrin,
-- _Extracting Fω's programs from proofs in the Calculus of
-  Constructions_, by Christine Paulin-Mohring <<P89>>,
-- _The Constructive Engine_, by Gérard Huet <<H89>>,
-
-as well as a number of user guides:
-
-- _A short user's guide for the Constructions_ Version 4.10, by Gérard Huet
-- _A Vernacular Syllabus_, by Gilles Dowek.
-- _The Tactics Theorem Prover, User's guide_, Version 4.10, by Thierry
-  Coquand.
-
-Stable V4.10, released on May 1st, 1989, was then a mature system,
-distributed with CAML V2.6.
-
-In the mean time, Thierry Coquand and Christine Paulin-Mohring had
-been investigating how to add native inductive types to the Calculus
-of Constructions, in the manner of Per Martin-Löf's Intuitionistic
-Type Theory. The impredicative encoding had already been presented in:
-F. Pfenning and C. Paulin-Mohring. __Inductively defined types in the
-Calculus of Constructions__ <<PP90>>. An extension of the calculus
-with primitive inductive types appeared in: Th. Coquand and
-C. Paulin-Mohring. __Inductively defined types__ <<CP90>>.
-
-This led to the Calculus of Inductive Constructions, logical formalism
-implemented in Versions 5 upward of the system, and documented in:
-C. Paulin-Mohring. __Inductive Definitions in the System Coq - Rules
-and Properties__ <<P93>>.
-
-The last version of CONSTR is Version 4.11, which was last distributed
-in the spring of 1990. It was demonstrated at the first workshop of
-the European Basic Research Action Logical Frameworks In Sophia
-Antipolis in May 1990.
-
-At the end of 1989, Version 5.1 was started, and renamed as the system
-Coq for the Calculus of Inductive Constructions. It was then ported to
-the new stand-alone implementation of ML called Caml-light.
-
-In 1990 many changes occurred. Thierry Coquand left for Chalmers
-University in Göteborg. Christine Paulin-Mohring took a CNRS
-researcher position at the LIP laboratory of École Normale Supérieure
-de Lyon. Project Formel was terminated, and gave rise to two teams:
-Cristal at INRIA-Roquencourt, that continued developments in
-functional programming with Caml-light then Ocaml, and Coq, continuing
-the type theory research, with a joint team headed by Gérard Huet at
-INRIA-Rocquencourt and Christine Paulin-Mohring at the LIP laboratory
-of CNRS-ENS Lyon.
-
-Chetan Murthy joined the team in 1991 and became the main software
-architect of Version 5. He completely rehauled the implementation for
-efficiency.  Versions 5.6 and 5.8 were major distributed versions,
-with complete documentation and a library of users' developements. The
-use of the RCS revision control system, and systematic ChangeLog
-files, allow a more precise tracking of the software developments.
-
-Developments from Version 6 upwards are documented in the credits
-section of Coq's Reference Manual.
-
-====
-September 2015 +
-Thierry Coquand, Gérard Huet and Christine Paulin-Mohring.
-====
-
-[bibliography]
-.Bibliographic references
-
-- [[[CH85]]] Th. Coquand, G. Huet. _Constructions: A Higher Order
-  Proof System for Mechanizing Mathematics_. Invited paper, EUROCAL85,
-  April 1985, Linz, Austria. Springer Verlag LNCS 203, pp. 151-184.
-
-- [[[CH88]]] T. Coquand and G. Huet. _The Calculus of Constructions_.
-  Submitted on June 30th 1985, accepted on December 5th, 1985,
-  Information and Computation. Preprint as Rapport de Recherche Inria
-  n°530, Mai 1986. Final version in Information and Computation
-  76,2/3, Feb. 88.
-
-- [[[CH87]]] Th. Coquand, G. Huet. _Concepts Mathématiques et
-  Informatiques Formalisés dans le Calcul des Constructions_. Invited
-  paper, European Logic Colloquium, Orsay, July 1985. Preprint as
-  Rapport de recherche INRIA n°463, Dec. 85.  Published in Logic
-  Colloquium 1985, North-Holland, 1987.
-
-- [[[P86]]] C. Paulin. _Algorithm development in the Calculus of
-  Constructions_, preprint as Rapport de recherche INRIA n°497,
-  March 86. Final version in Proceedings Symposium on Logic in Computer
-  Science, Cambridge, MA, 1986 (IEEE Computer Society Press).
-
-- [[[H88]]] G. Huet. _Induction Principles Formalized in the Calculus
-  of Constructions_ in Programming of Future Generation Computers,
-  Ed. K. Fuchi and M. Nivat, North-Holland, 1988.
-
-- [[[C90]]] Th. Coquand. _Metamathematical Investigations of a
-  Calculus of Constructions_, by INRIA Research Report N°1088,
-  Sept. 1989, published in Logic and Computer Science,
-  ed. P.G. Odifreddi, Academic Press, 1990.
-
-- [[[P89]]] C. Paulin. _Extracting F ω's programs from proofs in the
-  calculus of constructions_. 16th Annual ACM Symposium on Principles
-  of Programming Languages, Austin. 1989.
-
-- [[[H89]]] G. Huet. _The constructive engine_. A perspective in
-  Theoretical Computer Science. Commemorative Volume for Gift
-  Siromoney. World Scientific Publishing (1989).
-
-- [[[PP90]]] F. Pfenning and C. Paulin-Mohring. _Inductively defined
-  types in the Calculus of Constructions_. Preprint technical report
-  CMU-CS-89-209, final version in Proceedings of Mathematical
-  Foundations of Programming Semantics, volume 442, Lecture Notes in
-  Computer Science. Springer-Verlag, 1990
-
-- [[[CP90]]] Th. Coquand and C. Paulin-Mohring. _Inductively defined
-  types_.  In P. Martin-Löf and G. Mints, editors, Proceedings of
-  Colog'88, volume 417, Lecture Notes in Computer Science.
-  Springer-Verlag, 1990.
-
-- [[[P93]]] C. Paulin-Mohring. _Inductive Definitions in the System
-  Coq - Rules and Properties_. In M. Bezem and J.-F. Groote, editors,
-  Proceedings of the conference Typed Lambda Calculi and Applications,
-  volume 664, Lecture Notes in Computer Science, 1993.
diff --git a/doc/sphinx/biblio.bib b/doc/sphinx/biblio.bib
index d9eaa2c6c6..0467852b19 100644
--- a/doc/sphinx/biblio.bib
+++ b/doc/sphinx/biblio.bib
@@ -45,6 +45,58 @@ s},
   year        = {1972}
 }
 
+@inproceedings{CH85,
+  title={Constructions: a higher order proof system for mechanizing mathematics},
+  author={Coquand, Thierry and Huet, Gérard},
+  booktitle={European Conference on Computer Algebra},
+  pages={151--184},
+  year={1985},
+  issn         = {1611-3349},
+  doi          = {10.1007/3-540-15983-5_13},
+  url          = {http://dx.doi.org/10.1007/3-540-15983-5_13},
+  isbn         = 9783540396840,
+  publisher    = {Springer Berlin Heidelberg}
+}
+
+@techreport{CH88
+  TITLE = {{The calculus of constructions}},
+  AUTHOR = {Coquand, T. and Huet, G{\'e}rard},
+  URL = {https://hal.inria.fr/inria-00076024},
+  NUMBER = {RR-0530},
+  INSTITUTION = {{INRIA}},
+  YEAR = {1986},
+  MONTH = May,
+  PDF = {https://hal.inria.fr/inria-00076024/file/RR-0530.pdf},
+  HAL_ID = {inria-00076024},
+  HAL_VERSION = {v1},
+}
+
+@techreport{CH87,
+  TITLE = {{Concepts mathematiques et informatiques formalises dans le calcul des constructions}},
+  AUTHOR = {Coquand, T. and Huet, G{\'e}rard},
+  URL = {https://hal.inria.fr/inria-00076039},
+  NUMBER = {RR-0515},
+  INSTITUTION = {{INRIA}},
+  YEAR = {1986},
+  MONTH = Apr,
+  PDF = {https://hal.inria.fr/inria-00076039/file/RR-0515.pdf},
+  HAL_ID = {inria-00076039},
+  HAL_VERSION = {v1},
+}
+
+@techreport{C90,
+  TITLE = {{Metamathematical investigations of a calculus of constructions}},
+  AUTHOR = {Coquand, T.},
+  URL = {https://hal.inria.fr/inria-00075471},
+  NUMBER = {RR-1088},
+  INSTITUTION = {{INRIA}},
+  YEAR = {1989},
+  MONTH = Sep,
+  PDF = {https://hal.inria.fr/inria-00075471/file/RR-1088.pdf},
+  HAL_ID = {inria-00075471},
+  HAL_VERSION = {v1},
+}
+
 @PhDThesis{Coq85,
   author      = {Th. Coquand},
   month       = jan,
@@ -80,6 +132,19 @@ s},
   bibsource = {DBLP, http://dblp.uni-trier.de}
 }
 
+@inproceedings{CP90,
+  title={Inductively defined types},
+  author={Coquand, Thierry and Paulin, Christine},
+  booktitle={COLOG-88},
+  pages={50--66},
+  year={1990},
+  issn         = {1611-3349},
+  doi          = {10.1007/3-540-52335-9_47},
+  url          = {http://dx.doi.org/10.1007/3-540-52335-9_47},
+  isbn         = 9783540469636,
+  publisher    = {Springer Berlin Heidelberg}
+}
+
 @Book{Cur58,
   author      = {Haskell B. Curry and Robert Feys and William Craig},
   title       = {Combinatory Logic},
@@ -216,7 +281,19 @@ s},
   year        = {1980}
 }
 
-@InProceedings{Hue88,
+@inproceedings{H88,
+  title={Induction principles formalized in the Calculus of Constructions},
+  author={Huet, G{\'e}rard},
+  booktitle={Programming of Future Generation Computers. Elsevier Science},
+  year={1988},
+  issn         = {1611-3349},
+  doi          = {10.1007/3-540-17660-8_62},
+  url          = {http://dx.doi.org/10.1007/3-540-17660-8_62},
+  isbn         = 9783540477464,
+  publisher    = {Springer Berlin Heidelberg}
+}
+
+@InProceedings{H89,
   author      = {G. Huet},
   booktitle   = {A perspective in Theoretical Computer Science. Commemorative Volume for Gift Siromoney},
   editor      = {R. Narasimhan},
@@ -305,6 +382,50 @@ s},
   url       = {http://www.xmailserver.org/diff2.pdf}
 }
 
+@inproceedings{P86,
+  title={Algorithm development in the calculus of constructions},
+  author={Mohring, Christine},
+  booktitle={LICS},
+  pages={84--91},
+  year={1986}
+}
+
+@inproceedings{P89,
+  title={Extracting $\Omega$'s programs from proofs in the calculus of constructions},
+  author={Paulin-Mohring, Christine},
+  booktitle={Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages},
+  pages={89--104},
+  year={1989},
+  doi          = {10.1145/75277.75285},
+  url          = {http://dx.doi.org/10.1145/75277.75285},
+  isbn         = 0897912942,
+  organization = {ACM Press}
+}
+
+@inproceedings{P93,
+  title={Inductive definitions in the system coq rules and properties},
+  author={Paulin-Mohring, Christine},
+  booktitle={International Conference on Typed Lambda Calculi and Applications},
+  pages={328--345},
+  year={1993},
+  doi          = {10.1007/bfb0037116},
+  url          = {http://dx.doi.org/10.1007/bfb0037116},
+  isbn         = 3540565175,
+  organization = {Springer-Verlag}
+}
+
+@inproceedings{PP90,
+  title={Inductively defined types in the Calculus of Constructions},
+  author={Pfenning, Frank and Paulin-Mohring, Christine},
+  booktitle={International Conference on Mathematical Foundations of Programming Semantics},
+  pages={209--228},
+  year={1989},
+  doi          = {10.1007/bfb0040259},
+  url          = {http://dx.doi.org/10.1007/bfb0040259},
+  isbn         = 0387973753,
+  organization = {Springer-Verlag}
+}
+
 @InProceedings{Parent95b,
   author      = {C. Parent},
   booktitle   = {{Mathematics of Program Construction'95}},
diff --git a/doc/sphinx/credits.rst b/doc/sphinx/credits.rst
index 909af6e2f2..5873096523 100644
--- a/doc/sphinx/credits.rst
+++ b/doc/sphinx/credits.rst
@@ -2,10 +2,13 @@
 Credits
 -------
 
+Historical roots
+----------------
+
 Coq is a proof assistant for higher-order logic, allowing the
 development of computer programs consistent with their formal
-specification. It is the result of about ten years of research of the
-Coq project. We shall briefly survey here three main aspects: the
+specification. It is the result of about ten years [#years]_ of research
+of the Coq project. We shall briefly survey here three main aspects: the
 *logical language* in which we write our axiomatizations and
 specifications, the *proof assistant* which allows the development of
 verified mathematical proofs, and the *program extractor* which
@@ -21,8 +24,8 @@ prompted Russell to restrict predicate calculus with a stratification of
 *types*. This effort culminated with *Principia Mathematica*, the first
 systematic attempt at a formal foundation of mathematics. A
 simplification of this system along the lines of simply typed
-:math:`\lambda`-calculus occurred with Church’s *Simple Theory of
-Types*. The :math:`\lambda`-calculus notation, originally used for
+λ-calculus occurred with Church’s *Simple Theory of
+Types*. The λ-calculus notation, originally used for
 expressing functionality, could also be used as an encoding of natural
 deduction proofs. This Curry-Howard isomorphism was used by N. de Bruijn
 in the *Automath* project, the first full-scale attempt to develop and
@@ -32,7 +35,7 @@ Exploiting this Curry-Howard isomorphism, notable achievements in proof
 theory saw the emergence of two type-theoretic frameworks; the first
 one, Martin-Löf’s *Intuitionistic Theory of Types*, attempts a new
 foundation of mathematics on constructive principles. The second one,
-Girard’s polymorphic :math:`\lambda`-calculus :math:`F_\omega`, is a
+Girard’s polymorphic λ-calculus :math:`F_\omega`, is a
 very strong functional system in which we may represent higher-order
 logic proof structures. Combining both systems in a higher-order
 extension of the Automath language, T. Coquand presented in 1985 the
@@ -107,15 +110,27 @@ advantage of special hardware, debuggers, and the like. We hope that |Coq|
 can be of use to researchers interested in experimenting with this new
 methodology.
 
+.. [#years] At the time of writting, i.e. 1995.
+
+Brief summary of the versions up to 5.10
+----------------------------------------
+
+.. note::
+   This summary was written in 1995 together with the previous
+   section and formed the initial version of the Credits chapter
+   (that has since then been appended to, at each new release).
+   A more comprehensive description of these early versions is
+   available in the next few sections, which were written in 2015.
+
 A first implementation of CoC was started in 1984 by G. Huet and T.
 Coquand. Its implementation language was CAML, a functional programming
 language from the ML family designed at INRIA in Rocquencourt. The core
 of this system was a proof-checker for CoC seen as a typed
-:math:`\lambda`-calculus, called the *Constructive Engine*. This engine
+λ-calculus, called the *Constructive Engine*. This engine
 was operated through a high-level notation permitting the declaration of
 axioms and parameters, the definition of mathematical types and objects,
 and the explicit construction of proof objects encoded as
-:math:`\lambda`-terms. A section mechanism, designed and implemented by
+λ-terms. A section mechanism, designed and implemented by
 G. Dowek, allowed hierarchical developments of mathematical theories.
 This high-level language was called the *Mathematical Vernacular*.
 Furthermore, an interactive *Theorem Prover* permitted the incremental
@@ -189,8 +204,324 @@ definitions of “inversion predicates”.
 | Gérard Huet
 |
 
-Credits: addendum for version 6.1
----------------------------------
+Version 1
+---------
+
+.. note::
+
+   These additional notes come from a document written
+   in September 2015 by Gérard Huet, Thierry Coquand and Christine Paulin
+   to accompany their public release of the archive of versions 1.10 to 6.2
+   of Coq and of its CONSTR ancestor. CONSTR, then Coq, was designed and
+   implemented in the Formel team, joint between the INRIA Rocquencourt
+   laboratory and the Ecole Normale Supérieure of Paris, from 1984
+   onwards.
+
+This software is a prototype type-checker for a higher-order logical
+formalism known as the Theory of Constructions, presented in his PhD
+thesis by Thierry Coquand, with influences from Girard's system F and
+de Bruijn's Automath.  The metamathematical analysis of the system is
+the PhD work of Thierry Coquand. The software is mostly the work of
+Gérard Huet.  Most of the mathematical examples verified with the
+software are due to Thierry Coquand.
+
+The programming language of the CONSTR software (as it was called at
+the time) was a version of ML adapted from the Edinburgh LCF system
+and running on a LISP backend. The main improvements from the original
+LCF ML were that ML was compiled rather than interpreted (Gérard Huet
+building on the original translator by Lockwood Morris), and that it
+was enriched by recursively defined types (work of Guy
+Cousineau). This ancestor of CAML was used and improved by Larry
+Paulson for his implementation of Cambridge LCF.
+
+Software developments of this prototype occurred from late 1983 to
+early 1985.
+
+Version 1.10 was frozen on December 22nd 1984. It is the version used
+for the examples in Thierry Coquand's thesis, defended on January 31st
+1985. There was a unique binding operator, used both for universal
+quantification (dependent product) at the level of types and
+functional abstraction (λ) at the level of terms/proofs, in the manner
+of Automath. Substitution (λ-reduction) was implemented using de
+Bruijn's indexes.
+
+Version 1.11 was frozen on February 19th, 1985. It is the version used
+for the examples in the paper: T. Coquand, G. Huet. *Constructions: A
+Higher Order Proof System for Mechanizing Mathematics* :cite:`CH85`.
+
+Christine Paulin joined the team at this point, for her DEA research
+internship.  In her DEA memoir (August 1985) she presents developments
+for the *lambo* function – :math:`\text{lambo}(f)(n)` computes the minimal
+:math:`m` such that :math:`f(m)` is greater than :math:`n`, for :math:`f`
+an increasing integer function, a challenge for constructive mathematics.
+She also encoded the majority voting algorithm of Boyer and Moore.
+
+Version 2
+---------
+
+The formal system, now renamed as the *Calculus of Constructions*, was
+presented with a proof of consistency and comparisons with proof
+systems of Per Martin Löf, Girard, and the Automath family of N. de
+Bruijn, in the paper: T. Coquand and G. Huet. *The Calculus of
+Constructions* :cite:`CH88`.
+
+An abstraction of the software design, in the form of an abstract
+machine for proof checking, and a fuller sequence of mathematical
+developments was presented in: T. Coquand, G. Huet. *Concepts
+Mathématiques et Informatiques Formalisés dans le Calcul des
+Constructions* :cite:`CH87`.
+
+Version 2.8 was frozen on December 16th, 1985, and served for
+developing the examples in the above papers.
+
+This calculus was then enriched in version 2.9 with a cumulative
+hierarchy of universes. Universe levels were initially explicit
+natural numbers.  Another improvement was the possibility of automatic
+synthesis of implicit type arguments, relieving the user of tedious
+redundant declarations.
+
+Christine Paulin wrote an article *Algorithm development in the
+Calculus of Constructions* :cite:`P86`. Besides *lambo* and *majority*,
+she presents *quicksort* and a text formatting algorithm.
+
+Version 2.13 of the Calculus of Constructions with universes was
+frozen on June 25th, 1986.
+
+A synthetic presentation of type theory along constructive lines with
+ML algorithms was given by Gérard Huet in his May 1986 CMU course
+notes *Formal Structures for Computation and Deduction*. Its chapter
+*Induction and Recursion in the Theory of Constructions* was presented
+as an invited paper at the Joint Conference on Theory and Practice of
+Software Development TAPSOFT’87 at Pise in March 1987, and published
+as *Induction Principles Formalized in the Calculus of
+Constructions* :cite:`H88`.
+
+Version 3
+---------
+
+This version saw the beginning of proof automation, with a search
+algorithm inspired from PROLOG and the applicative logic programming
+programs of the course notes *Formal structures for computation and
+deduction*.  The search algorithm was implemented in ML by Thierry
+Coquand.  The proof system could thus be used in two modes: proof
+verification and proof synthesis, with tactics such as ``AUTO``.
+
+The implementation language was now called CAML, for Categorical
+Abstract Machine Language. It used as backend the LLM3 virtual machine
+of Le Lisp by Jérôme Chailloux. The main developers of CAML were
+Michel Mauny, Ascander Suarez and Pierre Weis.
+
+V3.1 was started in the summer of 1986, V3.2 was frozen at the end of
+November 1986. V3.4 was developed in the first half of 1987.
+
+Thierry Coquand held a post-doctoral position in Cambrige University
+in 1986-87, where he developed a variant implementation in SML, with
+which he wrote some developments on fixpoints in Scott's domains.
+
+Version 4
+---------
+
+This version saw the beginning of program extraction from proofs, with
+two varieties of the type ``Prop`` of propositions, indicating
+constructive intent.  The proof extraction algorithms were implemented
+by Christine Paulin-Mohring.
+
+V4.1 was frozen on July 24th, 1987. It had a first identified library
+of mathematical developments (directory ``exemples``), with libraries
+``Logic`` (containing impredicative encodings of intuitionistic logic and
+algebraic primitives for booleans, natural numbers and list), ``Peano``
+developing second-order Peano arithmetic, ``Arith`` defining addition,
+multiplication, euclidean division and factorial. Typical developments
+were the Knaster-Tarski theorem and Newman's lemma from rewriting
+theory.
+
+V4.2 was a joint development of a team consisting of Thierry Coquand,
+Gérard Huet and Christine Paulin-Mohring. A file V4.2.log records the
+log of changes.  It was frozen on September 1987 as the last version
+implemented in CAML 2.3, and V4.3 followed on CAML 2.5, a more stable
+development system.
+
+V4.3 saw the first top-level of the system. Instead of evaluating
+explicit quotations, the user could develop his mathematics in a
+high-level language called the mathematical vernacular (following
+Automath terminology).  The user could develop files in the vernacular
+notation (with ``.v`` extension) which were now separate from the ``ml``
+sources of the implementation.  Gilles Dowek joined the team to
+develop the vernacular language as his DEA internship research.
+
+A notion of sticky constant was introduced, in order to keep names of
+lemmas when local hypotheses of proofs were discharged. This gave a
+notion of global mathematical environment with local sections.
+
+Another significant practical change was that the system, originally
+developped on the VAX central computer of our lab, was transferred on
+SUN personal workstations, allowing a level of distributed
+development.  The extraction algorithm was modified, with three
+annotations ``Pos``, ``Null`` and ``Typ`` decorating the sorts ``Prop``
+and ``Type``.
+
+Version 4.3 was frozen at the end of November 1987, and was
+distributed to an early community of users (among those were Hugo
+Herbelin and Loic Colson).
+
+V4.4 saw the first version of (encoded) inductive types.  Now natural
+numbers could be defined as::
+
+  [source, coq]
+  Inductive NAT : Prop = O : NAT | Succ : NAT->NAT.
+
+These inductive types were encoded impredicatively in the calculus,
+using a subsystem *rec* due to Christine Paulin.  V4.4 was frozen on
+March 6th 1988.
+
+Version 4.5 was the first one to support inductive types and program
+extraction.  Its banner was *Calcul des Constructions avec
+Réalisations et Synthèse*.  The vernacular language was enriched to
+accommodate extraction commands.
+
+The verification engine design was presented as: G. Huet. *The
+Constructive Engine*. Version 4.5. Invited Conference, 2nd European
+Symposium on Programming, Nancy, March 88.  The final paper,
+describing the V4.9 implementation, appeared in: A perspective in
+Theoretical Computer Science, Commemorative Volume in memory of Gift
+Siromoney, Ed. R. Narasimhan, World Scientific Publishing, 1989.
+
+Version 4.5 was demonstrated in June 1988 at the YoP Institute on
+Logical Foundations of Functional Programming organized by Gérard Huet
+at Austin, Texas.
+
+Version 4.6 was started during the summer of 1988. Its main
+improvement was the complete rehaul of the proof synthesis engine by
+Thierry Coquand, with a tree structure of goals.
+
+Its source code was communicated to Randy Pollack on September 2nd
+1988.  It evolved progressively into LEGO, proof system for Luo's
+formalism of Extended Calculus of Constructions.
+
+The discharge tactic was modified by Gérard Huet to allow for
+inter-dependencies in discharged lemmas. Christine Paulin improved the
+inductive definition scheme in order to accommodate predicates of any
+arity.
+
+Version 4.7 was started on September 6th, 1988.
+
+This version starts exploiting the CAML notion of module in order to
+improve the modularity of the implementation. Now the term verifier is
+identified as a proper module Machine, which the structure of its
+internal data structures being hidden and thus accessible only through
+the legitimate operations.  This machine (the constructive engine) was
+the trusted core of the implementation. The proof synthesis mechanism
+was a separate proof term generator. Once a complete proof term was
+synthesized with the help of tactics, it was entirely re-checked by
+the engine. Thus there was no need to certify the tactics, and the
+system took advantage of this fact by having tactics ignore the
+universe levels, universe consistency check being relegated to the
+final type-checking pass. This induced a certain puzzlement in early
+users who saw, after a successful proof search, their ``QED`` followed
+by silence, followed by a failure message due to a universe
+inconsistency…
+
+The set of examples comprise set theory experiments by Hugo Herbelin,
+and notably the Schroeder-Bernstein theorem.
+
+Version 4.8, started on October 8th, 1988, saw a major
+re-implementation of the abstract syntax type ``constr``, separating
+variables of the formalism and metavariables denoting incomplete terms
+managed by the search mechanism.  A notion of level (with three values
+``TYPE``, ``OBJECT`` and ``PROOF``) is made explicit and a type judgement
+clarifies the constructions, whose implementation is now fully
+explicit. Structural equality is speeded up by using pointer equality,
+yielding spectacular improvements. Thierry Coquand adapts the proof
+synthesis to the new representation, and simplifies pattern matching
+to first-order predicate calculus matching, with important performance
+gain.
+
+A new representation of the universe hierarchy is then defined by
+Gérard Huet.  Universe levels are now implemented implicitly, through
+a hidden graph of abstract levels constrained with an order relation.
+Checking acyclicity of the graph insures well-foundedness of the
+ordering, and thus consistency. This was documented in a memo *Adding
+Type:Type to the Calculus of Constructions* which was never published.
+
+The development version is released as a stable 4.8 at the end of
+1988.
+
+Version 4.9 is released on March 1st 1989, with the new "elastic"
+universe hierarchy.
+
+The spring of 1989 saw the first attempt at documenting the system
+usage, with a number of papers describing the formalism:
+
+- *Metamathematical Investigations of a Calculus of Constructions*, by
+  Thierry Coquand :cite:`C90`,
+
+- *Inductive definitions in the Calculus of Constructions*, by
+  Christine Paulin-Mohrin,
+
+- *Extracting Fω's programs from proofs in the Calculus of
+  Constructions*, by Christine Paulin-Mohring* :cite:`P89`,
+
+- *The Constructive Engine*, by Gérard Huet :cite:`H89`,
+
+as well as a number of user guides:
+
+- *A short user's guide for the Constructions*, Version 4.10, by Gérard Huet
+- *A Vernacular Syllabus*, by Gilles Dowek.
+- *The Tactics Theorem Prover, User's guide*, Version 4.10, by Thierry
+  Coquand.
+
+Stable V4.10, released on May 1st, 1989, was then a mature system,
+distributed with CAML V2.6.
+
+In the mean time, Thierry Coquand and Christine Paulin-Mohring had
+been investigating how to add native inductive types to the Calculus
+of Constructions, in the manner of Per Martin-Löf's Intuitionistic
+Type Theory. The impredicative encoding had already been presented in:
+F. Pfenning and C. Paulin-Mohring. *Inductively defined types in the
+Calculus of Constructions* :cite:`PP90`. An extension of the calculus
+with primitive inductive types appeared in: T. Coquand and
+C. Paulin-Mohring. *Inductively defined types* :cite:`CP90`.
+
+This led to the Calculus of Inductive Constructions, logical formalism
+implemented in Versions 5 upward of the system, and documented in:
+C. Paulin-Mohring. *Inductive Definitions in the System Coq - Rules
+and Properties* :cite:`P93`.
+
+The last version of CONSTR is Version 4.11, which was last distributed
+in the spring of 1990. It was demonstrated at the first workshop of
+the European Basic Research Action Logical Frameworks In Sophia
+Antipolis in May 1990.
+
+Version 5
+---------
+
+At the end of 1989, Version 5.1 was started, and renamed as the system
+Coq for the Calculus of Inductive Constructions. It was then ported to
+the new stand-alone implementation of ML called Caml-light.
+
+In 1990 many changes occurred. Thierry Coquand left for Chalmers
+University in Göteborg. Christine Paulin-Mohring took a CNRS
+researcher position at the LIP laboratory of École Normale Supérieure
+de Lyon. Project Formel was terminated, and gave rise to two teams:
+Cristal at INRIA-Roquencourt, that continued developments in
+functional programming with Caml-light then OCaml, and Coq, continuing
+the type theory research, with a joint team headed by Gérard Huet at
+INRIA-Rocquencourt and Christine Paulin-Mohring at the LIP laboratory
+of CNRS-ENS Lyon.
+
+Chetan Murthy joined the team in 1991 and became the main software
+architect of Version 5. He completely rehauled the implementation for
+efficiency.  Versions 5.6 and 5.8 were major distributed versions,
+with complete documentation and a library of users' developements. The
+use of the RCS revision control system, and systematic ChangeLog
+files, allow a more precise tracking of the software developments.
+
+| September 2015 +
+| Thierry Coquand, Gérard Huet and Christine Paulin-Mohring.
+|
+
+Version 6.1
+-----------
 
 The present version 6.1 of |Coq| is based on the V5.10 architecture. It
 was ported to the new language Objective Caml by Bruno Barras. The
@@ -226,8 +557,8 @@ Barras.
 | Christine Paulin
 |
 
-Credits: addendum for version 6.2
----------------------------------
+Version 6.2
+-----------
 
 In version 6.2 of |Coq|, the parsing is done using camlp4, a preprocessor
 and pretty-printer for CAML designed by Daniel de Rauglaudre at INRIA.
@@ -271,8 +602,8 @@ Loiseleur.
 | Christine Paulin
 |
 
-Credits: addendum for version 6.3
----------------------------------
+Version 6.3
+-----------
 
 The main changes in version V6.3 were the introduction of a few new
 tactics and the extension of the guard condition for fixpoint
@@ -304,8 +635,8 @@ Monin from CNET Lannion.
 | Christine Paulin
 |
 
-Credits: versions 7
--------------------
+Versions 7
+----------
 
 The version V7 is a new implementation started in September 1999 by
 Jean-Christophe Filliâtre. This is a major revision with respect to the
@@ -393,8 +724,8 @@ J.-F. Monin from France Telecom R & D.
 | Hugo Herbelin & Christine Paulin
 |
 
-Credits: version 8.0
---------------------
+Version 8.0
+-----------
 
 Coq version 8 is a major revision of the |Coq| proof assistant. First, the
 underlying logic is slightly different. The so-called *impredicativity*
@@ -495,8 +826,8 @@ under the responsibility of Christine Paulin.
 | (updated Apr. 2006)
 |
 
-Credits: version 8.1
---------------------
+Version 8.1
+-----------
 
 Coq version 8.1 adds various new functionalities.
 
@@ -574,8 +905,8 @@ and Yale University.
 | Hugo Herbelin
 |
 
-Credits: version 8.2
---------------------
+Version 8.2
+-----------
 
 Coq version 8.2 adds new features, new libraries and improves on many
 various aspects.
@@ -668,8 +999,8 @@ the Coq-Club mailing list.
 | Hugo Herbelin
 |
 
-Credits: version 8.3
---------------------
+Version 8.3
+-----------
 
 Coq version 8.3 is before all a transition version with refinements or
 extensions of the existing features and libraries and a new tactic nsatz
@@ -742,8 +1073,8 @@ Pierce for the excellent teaching materials they provided.
 | Hugo Herbelin
 |
 
-Credits: version 8.4
---------------------
+Version 8.4
+-----------
 
 Coq version 8.4 contains the result of three long-term projects: a new
 modular library of arithmetic by Pierre Letouzey, a new proof engine by
@@ -898,8 +1229,8 @@ Eelis van der Weegen.
 | Hugo Herbelin
 |
 
-Credits: version 8.5
---------------------
+Version 8.5
+-----------
 
 Coq version 8.5 contains the result of five specific long-term projects:
 
@@ -916,7 +1247,7 @@ Coq version 8.5 contains the result of five specific long-term projects:
    Matthieu Sozeau.
 
 -  An implementation of primitive projections with
-   :math:`\eta`-conversion bringing significant performance improvements
+   :math:`\eta`\-conversion bringing significant performance improvements
    when using records by Matthieu Sozeau.
 
 The full integration of the proof engine, by Arnaud Spiwack and
@@ -967,10 +1298,10 @@ messages in case of inconsistencies and allowing higher-level algorithms
 like unification to be entirely type safe. The internal representation
 of universes has been modified but this is invisible to the user.
 
-The underlying logic has been extended with :math:`\eta`-conversion for
+The underlying logic has been extended with :math:`\eta`\-conversion for
 records defined with primitive projections by Matthieu Sozeau. This
-additional form of :math:`\eta`-conversion is justified using the same
-principle than the previously added :math:`\eta`-conversion for function
+additional form of :math:`\eta`\-conversion is justified using the same
+principle than the previously added :math:`\eta`\-conversion for function
 types, based on formulations of the Calculus of Inductive Constructions
 with typed equality. Primitive projections, which do not carry the
 parameters of the record and are rigid names (not defined as a
@@ -1052,8 +1383,8 @@ Tankink. Maxime Dénès coordinated the release process.
 | Hugo Herbelin, Matthieu Sozeau and the |Coq| development team
 |
 
-Credits: version 8.6
---------------------
+Version 8.6
+-----------
 
 Coq version 8.6 contains the result of refinements, stabilization of
 8.5’s features and cleanups of the internals of the system. Over the
@@ -1192,8 +1523,8 @@ Dénès to put together a |Coq| consortium.
 | Matthieu Sozeau and the |Coq| development team
 |
 
-Credits: version 8.7
---------------------
+Version 8.7
+-----------
 
 |Coq| version 8.7 contains the result of refinements, stabilization of features
 and cleanups of the internals of the system along with a few new features. The
@@ -1298,8 +1629,8 @@ system, is now upcoming and will rely on Inria’s newly created Foundation.
 | Matthieu Sozeau and the |Coq| development team
 |
 
-Credits: version 8.8
---------------------
+Version 8.8
+-----------
 
 |Coq| version 8.8 contains the result of refinements and stabilization of
 features and deprecations, cleanups of the internals of the system along
@@ -1405,8 +1736,8 @@ The contacts of the Coq Consortium are Yves Bertot and Maxime Dénès.
 | Matthieu Sozeau for the |Coq| development team
 |
 
-Credits: version 8.9
---------------------
+Version 8.9
+-----------
 
 |Coq| version 8.9 contains the result of refinements and stabilization
 of features and deprecations or removals of deprecated features,
diff --git a/doc/sphinx/proof-engine/proof-handling.rst b/doc/sphinx/proof-engine/proof-handling.rst
index 2300a317f1..27360f02d3 100644
--- a/doc/sphinx/proof-engine/proof-handling.rst
+++ b/doc/sphinx/proof-engine/proof-handling.rst
@@ -30,7 +30,7 @@ When a proof is completed, the message ``Proof completed`` is displayed.
 One can then register this proof as a defined constant in the
 environment. Because there exists a correspondence between proofs and
 terms of λ-calculus, known as the *Curry-Howard isomorphism*
-:cite:`How80,Bar81,Gir89,Hue88`, |Coq| stores proofs as terms of |Cic|. Those
+:cite:`How80,Bar81,Gir89,H89`, |Coq| stores proofs as terms of |Cic|. Those
 terms are called *proof terms*.