rhetenor/awesome-awesomeness
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update lists

Browse Source
This commit is contained in:
Jonas Zeunert
2025-07-18 22:22:32 +02:00
parent 55bed3b4a1
commit 5916c5c074
3078 changed files with 331679 additions and 357255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
terminal/coq
View File

@@ -1,4 +1,4 @@
 Awesome Coq !Awesome (https://awesome.re/badge.svg) (https://awesome.re)
 Awesome Coq !Awesome (https://awesome.re/badge.svg) (https://awesome.re)
 (https://github.com/coq-community/manifesto)
@@ -27,7 +27,7 @@
 - Course Material (#course-material)
 - Tutorials and Hints (#tutorials-and-hints)
――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
Projects
@@ -55,7 +55,7 @@
- Proof General (https://proofgeneral.github.io) - Generic interface for proof assistants based on the extensible, customizable text editor Emacs.
- Company-Coq (https://github.com/cpitclaudel/company-coq) - IDE extensions for Proof General's Coq mode.
- opam-switch-mode (https://github.com/ProofGeneral/opam-switch-mode) - IDE extension for Proof General to locally change or reset the opam switch from a menu or using a command.
- jsCoq (https://github.com/ejgallego/jscoq) - Port of Coq to JavaScript, which enables running Coq projects in a browser.
- jsCoq (https://github.com/jscoq/jscoq) - Port of Coq to JavaScript, which enables running Coq projects in a browser.
- Jupyter kernel for Coq (https://github.com/EugeneLoy/coq_jupyter) - Coq support for the Jupyter Notebook web environment.
- VsCoq (https://github.com/coq-community/vscoq) - Language server and extension for the Visual Studio Code and VSCodium editors.
- VsCoq Legacy (https://github.com/coq-community/vscoq/tree/vscoq1) - Backwards-compatible extension for the Visual Studio Code and VSCodium editors using Coq's legacy XML protocol.
@@ -70,6 +70,7 @@
- CertiGraph (https://github.com/Salamari/CertiGraph) - Library for reasoning about directed graphs and their embedding in separation logic.
- CoLoR (https://github.com/fblanqui/color) - Library on rewriting theory, lambda-calculus and termination, with sub-libraries on common data structures extending the Coq standard library.
- coq-haskell (https://github.com/jwiegley/coq-haskell) - Library smoothing the transition to Coq for Haskell users.
- Coq-Kruskal (https://github.com/DmxLarchey/Coq-Kruskal) - Collection of libraries related to rose trees and Kruskal's tree theorem.
- CoqInterval (https://gitlab.inria.fr/coqinterval/interval/) - Tactics for performing proofs of inequalities on expressions of real numbers.
- Coq record update (https://github.com/tchajed/coq-record-update) - Library which provides a generic way to update Coq record fields.
- Coq-std++ (https://gitlab.mpi-sws.org/iris/stdpp) - Extended alternative standard library for Coq.
@@ -108,10 +109,9 @@
Plugins
- AAC Tactics (https://github.com/coq-community/aac-tactics) - Tactics for rewriting universally quantified equations, modulo associativity and commutativity of some operator.
- Coinduction (https://github.com/damien-pous/coinduction) - Plugin for doing proofs by enhanced coinduction.
- Coq-Elpi (https://github.com/LPCIC/coq-elpi) - Extension framework based on λProlog providing an extensive API to implement commands and tactics.
- Waterproof proof language (https://github.com/impermeable/coq-waterproof) - Plugin providing a language for writing proof scripts in a style that resembles non-mechanized mathematical proof.
- CoqHammer (https://github.com/lukaszcz/coqhammer) - General-purpose automated reasoning hammer tool that combines learning from previous proofs with the translation of problems to automated provers and the reconstruction of found 
proofs.
- CoqHammer (https://github.com/lukaszcz/coqhammer) - General-purpose automated reasoning hammer tool that combines learning from previous proofs with the translation of problems to automated provers and the reconstruction of found proofs.
- Equations (https://github.com/mattam82/Coq-Equations) - Function definition package for Coq.
- Gappa (https://gitlab.inria.fr/gappa/coq) - Tactic for discharging goals about floating-point arithmetic and round-off errors.
- Hierarchy Builder (https://github.com/math-comp/hierarchy-builder) - Collection of commands for declaring Coq hierarchies based on packed classes.
@@ -122,9 +122,9 @@
- Paramcoq (https://github.com/coq-community/paramcoq) - Plugin to generate parametricity translations of Coq terms.
- QuickChick (https://github.com/QuickChick/QuickChick) - Plugin for randomized property-based testing.
- SMTCoq (https://github.com/smtcoq/smtcoq) - Tool that checks proof witnesses coming from external SAT and SMT solvers.
- Tactician (https://coq-tactician.github.io) - Interactive tool which learns from previously written tactic scripts across all the installed Coq packages and suggests the next tactic to be executed or tries to automate proof synthesis 
fully.
- Tactician (https://coq-tactician.github.io) - Interactive tool which learns from previously written tactic scripts across all the installed Coq packages and suggests the next tactic to be executed or tries to automate proof synthesis fully.
- Unicoq (https://github.com/unicoq/unicoq) - Plugin that replaces the existing unification algorithm with an enhanced one.
- Waterproof proof language (https://github.com/impermeable/coq-waterproof) - Plugin providing a language for writing proof scripts in a style that resembles non-mechanized mathematical proof.
Puzzles and Games
@@ -139,7 +139,7 @@
Tools
- Alectryon (https://github.com/cpitclaudel/alectryon) - Collection of tools for writing technical documents that mix Coq code and prose.
- Autosubst 2 (https://github.com/uds-psl/autosubst2) - Tool that generates Coq code for handling binders in syntax, such as for renaming and substitutions.
- Autosubst-ocaml (https://github.com/uds-psl/autosubst-ocaml) - Tool that generates Coq code for handling binders in syntax, such as for renaming and substitutions.
- CFML (https://gitlab.inria.fr/charguer/cfml2) - Tool for proving properties of OCaml programs in separation logic.
- coq2html (https://github.com/xavierleroy/coq2html) - Alternative HTML documentation generator for Coq.
- coqdoc (https://coq.inria.fr/refman/using/tools/coqdoc.html) - Standard documentation tool that generates LaTeX or HTML files from Coq code.
@@ -162,7 +162,7 @@
- Ott (https://github.com/ott-lang/ott) - Tool for writing definitions of programming languages and calculi that can be translated to Coq.
- PyCoq (https://github.com/ejgallego/pycoq) - Set of bindings and libraries for interacting with Coq from inside Python 3.
- Roosterize (https://github.com/EngineeringSoftware/roosterize) - Tool for suggesting lemma names in Coq projects.
- Sail (https://github.com/rems-project/sail) - Tool for specifying instruction set architecture semantics of processors and generating Coq definitions.
- Sail (https://github.com/rems-project/sail) - Tool for specifying instruction set architecture (ISA) semantics of processors and generating Coq definitions.
- SerAPI (https://github.com/ejgallego/coq-serapi) - Tools and OCaml library for (de)serialization of Coq code to and from JSON and S-expressions.
- Trakt (https://github.com/ecranceMERCE/trakt) - Generic goal preprocessing tool for proof automation tactics.
@@ -193,6 +193,7 @@
- CompCert (http://compcert.inria.fr) - High-assurance compiler for almost all of the C language (ISO C99), generating efficient code for the PowerPC, ARM, RISC-V and x86 processors.
- Ceramist (https://github.com/certichain/ceramist) - Verified hash-based approximate membership structures such as Bloom filters.
- CertiCoq (https://github.com/CertiCoq/certicoq) - Verified compiler from Gallina, the internal language of Coq, down to CompCert's Clight language.
- Fiat-Crypto (https://github.com/mit-plv/fiat-crypto) - Cryptographic primitive code generation.
- Functional Algorithms Verified in SSReflect (https://github.com/clayrat/fav-ssr) - Purely functional verified implementations of algorithms for searching, sorting, and other fundamental problems.
- Incremental Cycles (https://gitlab.inria.fr/agueneau/incremental-cycles) - Verified OCaml implementation of an algorithm for incremental cycle detection in graphs.
@@ -201,6 +202,7 @@
- lambda-rust (https://gitlab.mpi-sws.org/iris/lambda-rust) - Formal model of a Rust core language and type system, a logical relation for the type system, and safety proofs for some Rust libraries.
- Prosa (https://gitlab.mpi-sws.org/RT-PROOFS/rt-proofs) - Definitions and proofs for real-time system schedulability analysis.
- RISC-V Specification in Coq (https://github.com/mit-plv/riscv-coq) - Definition of the RISC-V processor instruction set architecture and extensions.
- Stable sort algorithms in Coq (https://github.com/pi8027/stablesort) - Generic and modular proofs of correctness, including stability, of mergesort functions.
- Tarjan and Kosaraju (https://github.com/math-comp/tarjan) - Verified implementations of algorithms for topological sorting and finding strongly connected components in finite graphs.
- Vélus (http://velus.inria.fr) - Verified compiler for a Lustre/Scade-like dataflow synchronous language.
- Verdi Raft (https://github.com/uwplse/verdi-raft) - Implementation of the Raft distributed consensus protocol, verified in Coq using the Verdi framework.
@@ -217,18 +219,17 @@
- Official Coq Zulip chat (https://coq.zulipchat.com)
- Official Coq-Club mailing list (https://sympa.inria.fr/sympa/arc/coq-club)
- Official Coq wiki (https://github.com/coq/coq/wiki)
- Official Coq Twitter (https://twitter.com/CoqLang)
- Official Coq X/Twitter (https://x.com/CoqLang)
- Coq Zulip chat archive (https://coq.gitlab.io/zulip-archive/)
- Coq subreddit (https://www.reddit.com/r/Coq/)
- Coq tag on Stack Overflow (https://stackoverflow.com/questions/tagged/coq)
- Coq tag on Theoretical Computer Science Stack Exchange (https://cstheory.stackexchange.com/questions/tagged/coq)
- Coq tag on Proof Assistants Stack Exchange (https://proofassistants.stackexchange.com/questions/tagged/coq)
- Coq keyword on Zenodo (https://zenodo.org/search?q=keywords%3A%22Coq%22)
- coq-community package maintenance project (https://github.com/coq-community/manifesto)
- Coq-community package maintenance project (https://github.com/coq-community/manifesto)
- Mathematical Components wiki (https://github.com/math-comp/math-comp/wiki)
- 100 famous theorems proved using Coq (https://github.com/coq-community/coq-100-theorems)
- Planet Coq link aggregator (https://coq.pl-a.net)
- Sherlocoq code search (https://sherlocoq.sirref.org)
Blogs
@@ -247,20 +248,27 @@
- Coq'Art (https://www.labri.fr/perso/casteran/CoqArt/) - The first book dedicated to Coq.
- Software Foundations (https://softwarefoundations.cis.upenn.edu) - Series of Coq-based textbooks on logic, functional programming, and foundations of programming languages, aimed at being accessible to beginners.
 - Volume 1: Logical Foundations (https://softwarefoundations.cis.upenn.edu/lf-current/index.html) - Introduction to functional programming, basic concepts of logic, and computer-assisted theorem proving.
 - Volume 2: Programming Language Foundations (https://softwarefoundations.cis.upenn.edu/plf-current/index.html) - Introduction to the theory of programming languages, including operational semantics, Hoare logic, and static type systems.
 - Volume 3: Verified Functional Algorithms (https://softwarefoundations.cis.upenn.edu/vfa-current/index.html) - Demonstration of how a variety of fundamental data structures can be specified and verified.
 - Volume 4: QuickChick (https://softwarefoundations.cis.upenn.edu/qc-current/index.html) - Introduction to tools for combining randomized property-based testing with formal specification and proof.
 - Volume 5: Verifiable C (https://softwarefoundations.cis.upenn.edu/vc-current/index.html) - An extended tutorial on specifying and verifying C programs using the Verified Software Toolchain.
 - Volume 6: Separation Logic Foundations (https://softwarefoundations.cis.upenn.edu/slf-current/index.html) - An introduction to separation logic and how to build program verification tools on top of it.
- Certified Programming with Dependent Types (http://adam.chlipala.net/cpdt/) - Textbook about practical engineering with Coq which teaches advanced practical tricks and a very specific style of proof.
- Program Logics for Certified Compilers (https://www.cs.princeton.edu/~appel/papers/plcc.pdf) - Book that explains how to construct program logics using separation logic, accompanied by a formal model in Coq which is applied to the 
Clight programming language and other examples.
- Program Logics for Certified Compilers (https://www.cs.princeton.edu/~appel/papers/plcc.pdf) - Book that explains how to construct program logics using separation logic, accompanied by a formal model in Coq which is applied to the Clight 
programming language and other examples.
- Formal Reasoning About Programs (http://adam.chlipala.net/frap/) - Book that simultaneously provides a general introduction to formal logical reasoning about the correctness of programs and to using Coq for this purpose.
- Programs and Proofs (https://ilyasergey.net/pnp/) - Book that gives a brief and practically-oriented introduction to interactive proofs in Coq which emphasizes the computational nature of inductive reasoning about decidable 
propositions via a small set of primitives from the SSReflect proof language.
- Computer Arithmetic and Formal Proofs (http://iste.co.uk/book.php?id=1238) - Book that describes how to formally specify and verify floating-point algorithms in Coq using the Flocq library.
- Programs and Proofs (https://ilyasergey.net/pnp/) - Book that gives a brief and practically-oriented introduction to interactive proofs in Coq which emphasizes the computational nature of inductive reasoning about decidable propositions via a 
small set of primitives from the SSReflect proof language.
- Computer Arithmetic and Formal Proofs (https://www.sciencedirect.com/book/9781785481123/computer-arithmetic-and-formal-proofs) - Book that describes how to formally specify and verify floating-point algorithms in Coq using the Flocq library.
- The Mathematical Components book (https://math-comp.github.io/mcb/) - Book oriented towards mathematically inclined users, focusing on the Mathematical Components library and the SSReflect proof language.
- Modeling and Proving in Computational Type Theory (https://github.com/uds-psl/MPCTT) - Book covering topics in computational logic using Coq, including foundations, canonical case studies, and practical programming.
- Hydras & Co. (https://github.com/coq-community/hydra-battles) - Continuously in-progress book and library on Kirby and Paris' hydra battles and other entertaining formalized mathematics in Coq, including a proof of the Gödel-Rosser 
first incompleteness theorem.
- Hydras & Co. (https://github.com/coq-community/hydra-battles) - Continuously in-progress book and library on Kirby and Paris' hydra battles and other entertaining formalized mathematics in Coq, including a proof of the Gödel-Rosser first 
incompleteness theorem.
Course Material
- An Introduction to MathComp-Analysis (https://staff.aist.go.jp/reynald.affeldt/documents/karate-coq.pdf) - Lecture notes on getting started with the Mathematical Components library and using it for classical reasoning and real analysis.
- Foundations of Separation Logic (https://chargueraud.org/teach/verif/) - Introduction to using separation logic to reason about sequential imperative programs in Coq.
- Floating-Point Numbers and Formal Proof (https://github.com/thery/FlocqLecture) - Introductory course on Coq real numbers and floating-point numbers from the Flocq library.
- Introduction to the Theory of Computation (https://gitlab.com/umb-svl/turing) - Formalization to support an undergraduate course on the theory of computation, including languages and Turing machines.
@@ -268,6 +276,8 @@
- MathComp School (https://github.com/gares/math-comp-school-2022) - Coq sources for lessons and exercises that introduce the SSReflect proof language and the Mathematical Components library.
- Mechanized Semantics (https://github.com/xavierleroy/cdf-mech-sem) - Companion Coq sources for a course on programming language semantics at Collège de France.
- Program Logics (https://github.com/xavierleroy/cdf-program-logics) - Companion Coq sources for a course on program logics at Collège de France.
- Program verification with types and logic (https://gitlab.science.ru.nl/program-verification/course-2023-2024) - Lectures and exercise material for a course in programming language semantics, type systems and program logics, using Coq, at 
Radboud University Nijmegen.
- Proofs and Reliable Programming using Coq (https://team.inria.fr/stamp/proofs-and-reliable-programming-using-coq-2022/) - Introduction to developing and verifying programs with Coq.
Tutorials and Hints
@@ -275,7 +285,11 @@
- Coq'Art Exercises and Tutorials (https://github.com/coq-community/coq-art) - Coq code and exercises from the Coq'Art book, including additional tutorials.
- Coq in a Hurry (http://cel.archives-ouvertes.fr/inria-00001173) - Introduction to how Coq can be used to define logical concepts and functions and reason about them.
- Coq requirements in Common Criteria evaluations (https://inria.hal.science/hal-04452421) - Guide on how to write readable and reviewable Coq code in high assurance applications.
- Coq Tactics in Plain English (https://charlesaverill.github.io/ctpe/) - Guide to Coq tactics with explanations and examples.
- Learn X in Y minutes where X=Coq (https://learnxinyminutes.com/docs/coq/) - Whirlwind tour of Coq as a language.
- Lemma Overloading (https://github.com/coq-community/lemma-overloading) - Demonstration of design patterns for programming and proving with canonical structures.
- MathComp Tutorial Materials (https://github.com/math-comp/tutorial_material) - Source code for Mathematical Components tutorials.
- Mike Nahas's Coq Tutorial (https://mdnahas.github.io/doc/nahas_tutorial.html) - Basics of using Coq to write formal proofs.
- Tricks in Coq (https://github.com/tchajed/coq-tricks) - Tips, tricks, and features that are hard to discover.
- Tricks in Coq (https://github.com/coq-community/coq-tricks) - Tips, tricks, and features in Coq that are hard to discover.
coq Github: https://github.com/coq-community/awesome-coq