\[\begin{split}\newcommand{\alors}{\textsf{then}} \newcommand{\alter}{\textsf{alter}} \newcommand{\as}{\kw{as}} \newcommand{\Assum}[3]{\kw{Assum}(#1)(#2:#3)} \newcommand{\bool}{\textsf{bool}} \newcommand{\case}{\kw{case}} \newcommand{\conc}{\textsf{conc}} \newcommand{\cons}{\textsf{cons}} \newcommand{\consf}{\textsf{consf}} \newcommand{\conshl}{\textsf{cons\_hl}} \newcommand{\Def}[4]{\kw{Def}(#1)(#2:=#3:#4)} \newcommand{\emptyf}{\textsf{emptyf}} \newcommand{\End}{\kw{End}} \newcommand{\kwend}{\kw{end}} \newcommand{\EqSt}{\textsf{EqSt}} \newcommand{\even}{\textsf{even}} \newcommand{\evenO}{\textsf{even}_\textsf{O}} \newcommand{\evenS}{\textsf{even}_\textsf{S}} \newcommand{\false}{\textsf{false}} \newcommand{\filter}{\textsf{filter}} \newcommand{\Fix}{\kw{Fix}} \newcommand{\fix}{\kw{fix}} \newcommand{\for}{\textsf{for}} \newcommand{\forest}{\textsf{forest}} \newcommand{\from}{\textsf{from}} \newcommand{\Functor}{\kw{Functor}} \newcommand{\haslength}{\textsf{has\_length}} \newcommand{\hd}{\textsf{hd}} \newcommand{\ident}{\textsf{ident}} \newcommand{\In}{\kw{in}} \newcommand{\Ind}[4]{\kw{Ind}[#2](#3:=#4)} \newcommand{\ind}[3]{\kw{Ind}~[#1]\left(#2\mathrm{~:=~}#3\right)} \newcommand{\Indp}[5]{\kw{Ind}_{#5}(#1)[#2](#3:=#4)} \newcommand{\Indpstr}[6]{\kw{Ind}_{#5}(#1)[#2](#3:=#4)/{#6}} \newcommand{\injective}{\kw{injective}} \newcommand{\kw}[1]{\textsf{#1}} \newcommand{\lb}{\lambda} \newcommand{\length}{\textsf{length}} \newcommand{\letin}[3]{\kw{let}~#1:=#2~\kw{in}~#3} \newcommand{\List}{\textsf{list}} \newcommand{\lra}{\longrightarrow} \newcommand{\Match}{\kw{match}} \newcommand{\Mod}[3]{{\kw{Mod}}({#1}:{#2}\,\zeroone{:={#3}})} \newcommand{\ModA}[2]{{\kw{ModA}}({#1}=={#2})} \newcommand{\ModS}[2]{{\kw{Mod}}({#1}:{#2})} \newcommand{\ModType}[2]{{\kw{ModType}}({#1}:={#2})} \newcommand{\mto}{.\;} \newcommand{\Nat}{\mathbb{N}} \newcommand{\nat}{\textsf{nat}} \newcommand{\Nil}{\textsf{nil}} \newcommand{\nilhl}{\textsf{nil\_hl}} \newcommand{\nO}{\textsf{O}} \newcommand{\node}{\textsf{node}} \newcommand{\nS}{\textsf{S}} \newcommand{\odd}{\textsf{odd}} \newcommand{\oddS}{\textsf{odd}_\textsf{S}} \newcommand{\ovl}[1]{\overline{#1}} \newcommand{\Pair}{\textsf{pair}} \newcommand{\Prod}{\textsf{prod}} \newcommand{\Prop}{\textsf{Prop}} \newcommand{\return}{\kw{return}} \newcommand{\Set}{\textsf{Set}} \newcommand{\si}{\textsf{if}} \newcommand{\sinon}{\textsf{else}} \newcommand{\Sort}{\cal S} \newcommand{\Str}{\textsf{Stream}} \newcommand{\Struct}{\kw{Struct}} \newcommand{\subst}[3]{#1\{#2/#3\}} \newcommand{\tl}{\textsf{tl}} \newcommand{\tree}{\textsf{tree}} \newcommand{\true}{\textsf{true}} \newcommand{\Type}{\textsf{Type}} \newcommand{\unfold}{\textsf{unfold}} \newcommand{\WEV}[3]{\mbox{$#1[] \vdash #2 \lra #3$}} \newcommand{\WEVT}[3]{\mbox{$#1[] \vdash #2 \lra$}\\ \mbox{$ #3$}} \newcommand{\WF}[2]{{\cal W\!F}(#1)[#2]} \newcommand{\WFE}[1]{\WF{E}{#1}} \newcommand{\WFT}[2]{#1[] \vdash {\cal W\!F}(#2)} \newcommand{\WFTWOLINES}[2]{{\cal W\!F}\begin{array}{l}(#1)\\\mbox{}[{#2}]\end{array}} \newcommand{\with}{\kw{with}} \newcommand{\WS}[3]{#1[] \vdash #2 <: #3} \newcommand{\WSE}[2]{\WS{E}{#1}{#2}} \newcommand{\WT}[4]{#1[#2] \vdash #3 : #4} \newcommand{\WTE}[3]{\WT{E}{#1}{#2}{#3}} \newcommand{\WTEG}[2]{\WTE{\Gamma}{#1}{#2}} \newcommand{\WTM}[3]{\WT{#1}{}{#2}{#3}} \newcommand{\zeroone}[1]{[{#1}]} \newcommand{\zeros}{\textsf{zeros}} \end{split}\]

# Introduction

This document is the Reference Manual of the Coq proof assistant. To start using Coq, it is advised to first read a tutorial. Links to several tutorials can be found at https://coq.inria.fr/documentation and https://github.com/coq/coq/wiki#coq-tutorials

The Coq system is designed to develop mathematical proofs, and especially to write formal specifications, programs and to verify that programs are correct with respect to their specifications. It provides a specification language named Gallina. Terms of Gallina can represent programs as well as properties of these programs and proofs of these properties. Using the so-called Curry-Howard isomorphism, programs, properties and proofs are formalized in the same language called Calculus of Inductive Constructions, that is a \(\lambda\)-calculus with a rich type system. All logical judgments in Coq are typing judgments. The very heart of the Coq system is the type checking algorithm that checks the correctness of proofs, in other words that checks that a program complies to its specification. Coq also provides an interactive proof assistant to build proofs using specific programs called tactics.

All services of the Coq proof assistant are accessible by interpretation of a command language called the vernacular.

Coq has an interactive mode in which commands are interpreted as the user types them in from the keyboard and a compiled mode where commands are processed from a file.

- In interactive mode, users can develop their theories and proofs step by step, and query the system for available theorems and definitions. The interactive mode is generally run with the help of an IDE, such as CoqIDE, documented in Coq Integrated Development Environment, Emacs with Proof-General [Asp00] [1], or jsCoq to run Coq in your browser (see https://github.com/ejgallego/jscoq). The coqtop read-eval-print-loop can also be used directly, for debugging purposes.
- The compiled mode acts as a proof checker taking a file containing a whole development in order to ensure its correctness. Moreover, Coq’s compiler provides an output file containing a compact representation of its input. The compiled mode is run with the coqc command.

See also

The Coq commands.

## How to read this book

This is a Reference Manual, so it is not intended for continuous reading. We recommend using the various indexes to quickly locate the documentation you are looking for. There is a global index, and a number of specific indexes for tactics, vernacular commands, and error messages and warnings. Nonetheless, the manual has some structure that is explained below.

- The first part describes the specification language, Gallina. Chapters The Gallina specification language and Extensions of Gallina describe the concrete syntax as well as the meaning of programs, theorems and proofs in the Calculus of Inductive Constructions. Chapter The Coq library describes the standard library of Coq. Chapter Calculus of Inductive Constructions is a mathematical description of the formalism. Chapter The Module System describes the module system.
- The second part describes the proof engine. It is divided in six chapters. Chapter Vernacular commands presents all commands (we call them vernacular commands) that are not directly related to interactive proving: requests to the environment, complete or partial evaluation, loading and compiling files. How to start and stop proofs, do multiple proofs in parallel is explained in Chapter Proof handling. In Chapter Tactics, all commands that realize one or more steps of the proof are presented: we call them tactics. The language to combine these tactics into complex proof strategies is given in Chapter The tactic language. Examples of tactics are described in Chapter Detailed examples of tactics. Finally, the SSReflect proof language is presented in Chapter The SSReflect proof language.
- The third part describes how to extend the syntax of Coq in Chapter Syntax extensions and interpretation scopes and how to define new induction principles in Chapter Proof schemes.
- In the fourth part more practical tools are documented. First in Chapter The Coq commands, the usage of coqc (batch mode) and coqtop (interactive mode) with their options is described. Then, in Chapter Utilities, various utilities that come with the Coq distribution are presented. Finally, Chapter Coq Integrated Development Environment describes CoqIDE.
- The fifth part documents a number of advanced features, including coercions, canonical structures, typeclasses, program extraction, and specialized solvers and tactics. See the table of contents for a complete list.

## List of additional documentation

This manual does not contain all the documentation the user may need about Coq. Various informations can be found in the following documents:

Tutorial
  A companion volume to this reference manual, the Coq Tutorial, is aimed at gently introducing new users to developing proofs in Coq without assuming prior knowledge of type theory. In a second step, the user can read also the tutorial on recursive types (document RecTutorial.ps).
Installation
  A text file INSTALL that comes with the sources explains how to install Coq.
The Coq standard library
  A commented version of sources of the Coq standard library (including only the specifications, the proofs are removed) is available at https://coq.inria.fr/stdlib/.

### Table of contents

Indexes

- Index
- Command index
- Tactic index
- Flags, options and tables index
- Errors and warnings index

Preamble

- Introduction
- Credits
  - Credits: addendum for version 6.1
  - Credits: addendum for version 6.2
  - Credits: addendum for version 6.3
  - Credits: versions 7
  - Credits: version 8.0
  - Credits: version 8.1
  - Credits: version 8.2
  - Credits: version 8.3
  - Credits: version 8.4
  - Credits: version 8.5
  - Credits: version 8.6
  - Credits: version 8.7
  - Credits: version 8.8

The language

- The Gallina specification language
  - About the grammars in the manual
  - Lexical conventions
  - Terms
    - Syntax of terms
    - Types
    - Qualified identifiers and simple identifiers
    - Numerals
    - Sorts
    - Binders
    - Abstractions
    - Products
    - Applications
    - Type cast
    - Inferable subterms
    - Let-in definitions
    - Definition by case analysis
    - Recursive functions
  - The Vernacular
    - Assumptions
    - Definitions
    - Inductive definitions
      - Simple inductive types
      - Simple annotated inductive types
      - Parametrized inductive types
      - Variants
      - Mutually defined inductive types
      - Co-inductive types
    - Definition of recursive functions
      - Definition of functions by recursion over inductive objects
      - Definitions of recursive objects in co-inductive types
    - Assertions and proofs
- Extensions of Gallina
  - Record types
    - Primitive Projections
      - Primitive Record Types
      - Reduction
      - Compatibility Projections and `match`
  - Variants and extensions of `match`
    - Multiple and nested pattern matching
    - Pattern-matching on boolean values: the if expression
    - Irrefutable patterns: the destructuring let variants
      - First destructuring let syntax
      - Second destructuring let syntax
    - Controlling pretty-printing of match expressions
      - Printing nested patterns
      - Factorization of clauses with same right-hand side
      - Use of a default clause
      - Printing of wildcard patterns
      - Printing of the elimination predicate
      - Printing matching on irrefutable patterns
      - Printing matching on booleans
  - Advanced recursive functions
  - Section mechanism
  - Module system
    - Reserved commands inside an interactive module
    - Reserved commands inside an interactive module type:
  - Libraries and qualified names
    - Names of libraries
    - Qualified names
    - Libraries and filesystem
  - Implicit arguments
    - The different kinds of implicit arguments
      - Implicit arguments inferable from the knowledge of other arguments of a function
      - Implicit arguments inferable by resolution
    - Maximal or non maximal insertion of implicit arguments
    - Casual use of implicit arguments
    - Declaration of implicit arguments
      - Implicit Argument Binders
      - Declaring Implicit Arguments
    - Automatic declaration of implicit arguments
    - Mode for automatic declaration of implicit arguments
    - Controlling strict implicit arguments
    - Controlling contextual implicit arguments
    - Controlling reversible-pattern implicit arguments
    - Controlling the insertion of implicit arguments not followed by explicit arguments
    - Explicit applications
    - Renaming implicit arguments
    - Displaying what the implicit arguments are
    - Explicit displaying of implicit arguments for pretty-printing
    - Interaction with subtyping
    - Deactivation of implicit arguments for parsing
    - Canonical structures
    - Implicit types of variables
    - Implicit generalization
  - Coercions
  - Printing constructions in full
  - Printing universes
  - Existential variables
    - Explicit displaying of existential instances for pretty-printing
    - Solving existential variables using tactics
- The Coq library
  - The basic library
    - Notations
    - Logic
      - Propositional Connectives
      - Quantifiers
      - Equality
      - Lemmas
    - Datatypes
      - Programming
    - Specification
    - Basic Arithmetics
    - Well-founded recursion
    - Accessing the Type level
    - Tactics
  - The standard library
    - Survey
    - Peano’s arithmetic (nat)
    - Notations for integer arithmetics
    - Real numbers library
      - Notations for real numbers
      - Some tactics for real numbers
    - List library
  - Users’ contributions
- Calculus of Inductive Constructions
  - The terms
    - Sorts
    - Terms
  - Typing rules
  - Conversion rules
    - β-reduction
    - ι-reduction
    - δ-reduction
    - ζ-reduction
    - η-expansion
    - Convertibility
  - Subtyping rules
  - Inductive Definitions
    - Types of inductive objects
    - Well-formed inductive definitions
      - Arity of a given sort
      - Arity
      - Type constructor
      - Positivity Condition
      - Strict positivity
      - Nested Positivity
      - Correctness rules
      - Template polymorphism
    - Destructors
      - The match ... with ... end construction
    - Fixpoint definitions
      - Typing rule
      - Reduction rule
  - Admissible rules for global environments
  - Co-inductive types
  - The Calculus of Inductive Constructions with impredicative Set
- The Module System
  - Modules and module types
  - Typing Modules

The proof engine

- Vernacular commands
  - Displaying
  - Flags, Options and Tables
    - Scope qualifiers for `Set` and `Unset`
  - Requests to the environment
  - Loading files
  - Compiled files
  - Loadpath
  - Backtracking
  - Quitting and debugging
  - Controlling display
  - Controlling the reduction strategies and the conversion algorithm
  - Controlling the locality of commands
- Proof handling
  - Switching on/off the proof editing mode
    - Proof using options
    - Name a set of section hypotheses for `Proof using`
  - Navigation in the proof tree
    - Bullets
    - Set Bullet Behavior
  - Requesting information
  - Controlling the effect of proof editing commands
  - Controlling memory usage
- Tactics
  - Invocation of tactics
    - Bindings list
    - Occurrence sets and occurrence clauses
  - Applying theorems
  - Managing the local context
  - Controlling the proof flow
  - Case analysis and induction
  - Rewriting expressions
  - Performing computations
    - Conversion tactics applied to hypotheses
  - Automation
  - Controlling automation
    - The hints databases for auto and eauto
      - Creating Hint databases
    - Hint databases defined in the Coq standard library
    - Hint locality
    - Setting implicit automation tactics
  - Decision procedures
  - Checking properties of terms
  - Equality
  - Equality and inductive sets
  - Inversion
  - Classical tactics
  - Automating
  - Non-logical tactics
  - Simple tactic macros
- The tactic language
  - Syntax
  - Semantics
    - Sequence
    - Local application of tactics
    - Goal selectors
    - For loop
    - Repeat loop
    - Error catching
    - Detecting progress
    - Backtracking branching
    - First tactic to work
    - Left-biased branching
    - Generalized biased branching
    - Soft cut
    - Checking the successes
    - Checking the failure
    - Checking the success
    - Solving
    - Identity
    - Failing
    - Timeout
    - Timing a tactic
    - Timing a tactic that evaluates to a term
    - Local definitions
    - Application
    - Function construction
    - Pattern matching on terms
    - Pattern matching on goals
    - Filling a term context
    - Generating fresh hypothesis names
    - Computing in a constr
    - Recovering the type of a term
    - Manipulating untyped terms
    - Counting the goals
    - Testing boolean expressions
    - Proving a subgoal as a separate lemma
  - Tactic toplevel definitions
    - Defining Ltac functions
    - Printing Ltac tactics
  - Debugging Ltac tactics
    - Info trace
    - Interactive debugger
    - Profiling Ltac tactics
    - Run-time optimization tactic
- Detailed examples of tactics
  - dependent induction
    - A larger example
  - autorewrite
  - quote
    - Introducing variables map
    - Combining variables and constants
  - Using the tactic language
    - About the cardinality of the set of natural numbers
    - Permutations of lists
    - Deciding intuitionistic propositional logic
    - Deciding type isomorphisms
- The SSReflect proof language
  - Introduction
    - Acknowledgments
  - Usage
    - Getting started
    - Compatibility issues
  - Gallina extensions
    - Pattern assignment
    - Pattern conditional
    - Parametric polymorphism
    - Anonymous arguments
    - Wildcards
    - Definitions
    - Abbreviations
      - Matching
      - Occurrence selection
    - Basic localization
  - Basic tactics
    - Bookkeeping
    - The defective tactics
      - The move tactic.
      - The case tactic
      - The elim tactic
      - The apply tactic
    - Discharge
      - Clear rules
      - Matching for apply and exact
      - The abstract tactic
    - Introduction in the context
    - Generation of equations
    - Type families
  - Control flow
    - Indentation and bullets
    - Terminators
    - Selectors
    - Iteration
    - Localization
    - Structure
      - The have tactic.
      - Generating let in context entries with have
      - The have tactic and typeclass resolution
      - Variants: the suff and wlog tactics
        - Advanced generalization
  - Rewriting
    - An extended rewrite tactic
    - Remarks and examples
      - Rewrite redex selection
      - Chained rewrite steps
      - Explicit redex switches are matched first
      - Occurrence switches and redex switches
      - Occurrence selection and repetition
      - Multi-rule rewriting
      - Wildcards vs abstractions
      - When SSReflect rewrite fails on standard Coq licit rewrite
      - Existential metavariables and rewriting
    - Locking, unlocking
    - Congruence
  - Contextual patterns
    - Syntax
    - Matching contextual patterns
    - Examples
      - Contextual pattern in set and the : tactical
      - Contextual patterns in rewrite
    - Patterns for recurrent contexts
  - Views and reflection
    - Interpreting eliminations
    - Interpreting assumptions
      - Specializing assumptions
    - Interpreting goals
    - Boolean reflection
    - The reflect predicate
    - General mechanism for interpreting goals and assumptions
      - Specializing assumptions
      - Interpreting assumptions
    - Interpreting equivalences
    - Declaring new Hint Views
    - Multiple views
  - SSReflect searching tool
  - Synopsis and Index
    - Parameters
    - Items and switches
    - Tactics
    - Tacticals
    - Commands

User extensions

- Syntax extensions and interpretation scopes
  - Notations
    - Basic notations
    - Precedences and associativity
    - Complex notations
    - Simple factorization rules
    - Displaying symbolic notations
    - The Infix command
    - Reserving notations
    - Simultaneous definition of terms and notations
    - Displaying information about notations
    - Locating notations
    - Notations and binders
      - Binders bound in the notation and parsed as identifiers
      - Binders bound in the notation and parsed as patterns
      - Binders bound in the notation and parsed as terms
      - Binders not bound in the notation
    - Notations with recursive patterns
    - Notations with recursive patterns involving binders
    - Predefined entries
    - Summary
      - Syntax of notations
      - Persistence of notations
  - Interpretation scopes
    - Global interpretation rules for notations
    - Local interpretation rules for notations
      - Local opening of an interpretation scope
      - Binding arguments of a constant to an interpretation scope
      - Binding types of arguments to an interpretation scope
    - The `type_scope` interpretation scope
    - The `function_scope` interpretation scope
    - Interpretation scopes used in the standard library of Coq
    - Displaying information about scopes
  - Abbreviations
  - Tactic Notations
- Proof schemes
  - Generation of induction principles with `Scheme`
    - Automatic declaration of schemes
    - Combined Scheme
  - Generation of induction principles with `Functional` `Scheme`
  - Generation of inversion principles with `Derive` `Inversion`

Practical tools

- The Coq commands
  - Interactive use (coqtop)
  - Batch compilation (coqc)
  - Customization at launch time
    - By resource file
    - By environment variables
    - By command line options
  - Compiled libraries checker (coqchk)
- Utilities
  - Using Coq as a library
  - Building a Coq project with coq_makefile
    - CoqMakefile.local
    - Timing targets and performance testing
    - Reusing/extending the generated Makefile
    - Building a subset of the targets with `-j`
  - Module dependencies
  - Documenting Coq files with coqdoc
    - Principles
      - Coq material inside documentation.
      - Pretty-printing.
      - Sections
      - Lists.
      - Rules.
      - Emphasis.
      - Escaping to LaTeX and HTML.
      - Verbatim
      - Hyperlinks
      - Hiding / Showing parts of the source.
    - Usage
      - Command line options
    - The coqdoc LaTeX style file
  - Embedded Coq phrases inside LaTeX documents
  - Coq and GNU Emacs
    - The Coq Emacs mode
    - Proof-General
  - Module specification
  - Man pages
- Coq Integrated Development Environment
  - Managing files and buffers, basic editing
  - Interactive navigation into Coq scripts
  - Trying tactics automatically
  - Proof folding
  - Vernacular commands, templates
  - Queries
  - Compilation
  - Customizations
  - Using Unicode symbols
    - Displaying Unicode symbols
    - Defining an input method for non-ASCII symbols
    - Character encoding for saved files

Addendum

- Extended pattern matching
  - Patterns
  - Multiple patterns
  - Aliasing subpatterns
  - Nested patterns
  - Disjunctive patterns
  - About patterns of parametric types
    - Parameters in patterns
  - Implicit arguments in patterns
  - Matching objects of dependent types
  - Understanding dependencies in patterns
  - When the elimination predicate must be provided
    - Dependent pattern matching
    - Multiple dependent pattern matching
    - Patterns in `in`
  - Using pattern matching to write proofs
  - Pattern-matching on inductive objects involving local definitions
  - Pattern-matching and coercions
  - When does the expansion strategy fail?
- Implicit Coercions
  - General Presentation
  - Classes
  - Coercions
  - Identity Coercions
  - Inheritance Graph
  - Declaring Coercions
  - Displaying Available Coercions
  - Activating the Printing of Coercions
  - Classes as Records
  - Coercions and Sections
  - Coercions and Modules
  - Examples
    - Coercion at function application
    - Coercion to a type
    - Coercion to a function
- Canonical Structures
  - Notation overloading
    - Derived Canonical Structures
  - Hierarchy of structures
    - Compact declaration of Canonical Structures
- Type Classes
  - Class and Instance declarations
  - Binding classes
  - Parameterized Instances
  - Sections and contexts
  - Building hierarchies
    - Superclasses
    - Substructures
  - Summary of the commands
    - Typeclasses Transparent, Typclasses Opaque
    - Options
    - Typeclasses eauto :=
- Omega: a solver for quantifier-free problems in Presburger Arithmetic
  - Description of `omega`
  - Arithmetical goals recognized by `omega`
  - Messages from `omega`
  - Using `omega`
  - Options
  - Technical data
    - Overview of the tactic
    - Overview of the OMEGA decision procedure
  - Bugs
- Micromega: tactics for solving arithmetic goals over ordered rings
  - Short description of the tactics
  - Positivstellensatz refutations
  - lra: a decision procedure for linear real and rational arithmetic
  - lia: a tactic for linear integer arithmetic
    - High level view of lia
    - Cutting plane proofs
    - Case split
  - nra: a proof procedure for non-linear arithmetic
  - nia: a proof procedure for non-linear integer arithmetic
  - psatz: a proof procedure for non-linear arithmetic
- Extraction of programs in OCaml and Haskell
  - Generating ML Code
  - Extraction Options
    - Setting the target language
    - Inlining and optimizations
    - Extra elimination of useless arguments
    - Realizing axioms
    - Realizing inductive types
    - Avoiding conflicts with existing filenames
  - Differences between Coq and ML type systems
  - Some examples
    - A detailed example: Euclidean division
    - Extraction's horror museum
    - Users' Contributions
- Program
  - Elaborating programs
    - Syntactic control over equalities
    - Program Definition
    - Program Fixpoint
    - Program Lemma
  - Solving obligations
  - Frequently Asked Questions
- The ring and field tactic families
  - What does this tactic do?
  - The variables map
  - Is it automatic?
  - Concrete usage in Coq
  - Adding a ring structure
  - How does it work?
  - Dealing with fields
  - Adding a new field structure
  - History of ring
  - Discussion
- Nsatz: tactics for proving equalities in integral domains
  - More about nsatz
- Generalized rewriting
  - Introduction to generalized rewriting
    - Relations and morphisms
    - Adding new relations and morphisms
    - Rewriting and non reflexive relations
    - Rewriting and non symmetric relations
    - Rewriting in ambiguous setoid contexts
  - Commands and tactics
    - First class setoids and morphisms
    - Tactics enabled on user provided relations
    - Printing relations and morphisms
    - Deprecated syntax and backward incompatibilities
  - Extensions
    - Rewriting under binders
    - Subrelations
    - Constant unfolding
  - Strategies for rewriting
    - Definitions
    - Usage
- Asynchronous and Parallel Proof Processing
  - Proof annotations
    - Automatic suggestion of proof annotations
  - Proof blocks and error resilience
    - Caveats
  - Interactive mode
    - Caveats
  - Batch mode
  - Limiting the number of parallel workers
- Miscellaneous extensions
  - Program derivation
- Polymorphic Universes
  - General Presentation
  - Polymorphic, Monomorphic
  - Cumulative, NonCumulative
    - An example of a proof using cumulativity
  - Cumulativity Weak Constraints
  - Global and local universes
  - Conversion and unification
  - Minimization
  - Explicit Universes
    - Polymorphic definitions

Reference

- Bibliography

### License

This material (the Coq Reference Manual) may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub). Options A and B are not elected.

[1] | Proof-General is available at https://proofgeneral.github.io/. Optionally, you can enhance it with the minor mode Company-Coq [PCC16] (see https://github.com/cpitclaudel/company-coq).