Package: alectryon
A library to process Coq snippets embedded in documents, showing goals and messages for each Coq sentence.  Also a literate programming toolkit for Coq.  The goal of Alectryon is to make it easy to write textbooks, blog posts, and other documents that mix Coq code and prose.Alectryon is typically used in one of three ways:As a library, through its Python APIAs a Docutils/Sphinx extension, allowing you to include annotated snippets into your reStructuredText and Markdown documents.  During compilation, Alectryon collects all.. coq::code blocks, feeds their contents to Coq, and incorporates the resulting goals and responses into the final document.As a standalone compiler, allowing you to include prose delimited by special(*| … |*)comments directly into your Coq source files (in the style of coqdoc).  When invoked, Alectryon translates your Coq file into a reStructuredText document and compiles it using the standard reStructuredText toolchain.For background information, check out thequickstart guideon the MIT PLV blog, theSLE2020 paper(open access) and itslive examples, or theconference talk.Alectryon is free software under a very permissive license.  If you use it, please remember tocite it, and please let me know!Some examples of use in the wild are linkedat the bottom of this page.  Please add your own work by submitting a PR!SetupTo install from OPAM and PyPI:opam install"coq-serapi>=8.10.0+0.7.0"(from theCoq OPAM archive)python3-mpip install alectryonTo install the latest version from Git, usepython3-mpip installgit+https://github.com/cpitclaudel/alectryon.git.  To install from a local clone, usepython3-mpip install ..A note on dependencies: theserapimodule only depends on thecoq-serapiOPAM package.dominateis used inalectryon.htmlto generate HTML output, andpygmentsis used by the command-line application for syntax highlighting.  reStructuredText support requiresdocutils(and optionallysphinx); Markdown support requiresmyst_parser(docs); Coqdoc support requiresbeautifulsoup4.  Support for Coq versions follows SerAPI; Coq ≥ 8.10 works well and ≥ 8.12 works best.UsageAs a standalone programRecipesTry these recipes in therecipesdirectory of this repository (for each task I listed two commands: a short one and a longer one making everything explicit):Generate an interactive webpage from a literate Coq file with reST comments (Coqdoc style):alectryon literate_coq.v
alectryon --frontend coq+rst --backend webpage literate_coq.v -o literate_coq.htmlGenerate an interactive webpage from a plain Coq file (Proof General style):alectryon --frontend coq plain.v
alectryon --frontend coq --backend webpage plain.v -o plain.v.htmlGenerate an interactive webpage from a Coqdoc file (compatibility mode):alectryon --frontend coqdoc coqdoc.v
alectryon --frontend coqdoc --backend webpage coqdoc.v -o coqdoc.htmlGenerate an interactive webpage from a reStructuredText document containing.. coq::directives (coqrst style):alectryon literate_reST.rst
alectryon --frontend rst --backend webpage literate_reST.rst -o literate_reST.htmlGenerate an interactive webpage from a Markdown document written in theMySTdialect, containing.. coq::directives:alectryon literate_MyST.md
alectryon --frontend md --backend webpage literate_MyST.md -o literate_MyST.htmlTranslate a reStructuredText document into a literate Coq file:alectryon literate_reST.rst -o literate_reST.v
alectryon --frontend rst --backend coq+rst literate_reST.rst -o literate_reST.vTranslate a literate Coq file into a reStructuredText document:alectryon literate_coq.v -o literate_coq.v.rst
alectryon --frontend coq+rst --backend rst literate_coq.v -o literate_coq.v.rstRecord goals and responses for fragments contained in a JSON source file:alectryon fragments.v.json
alectryon --frontend coq.json --backend json fragments.json -o fragments.v.io.jsonRecord goals and responses and format them as HTML for fragments contained in a JSON source file:alectryon fragments.v.json -o fragments.v.snippets.html
alectryon --frontend coq.json --backend snippets-html fragments.json -o fragments.v.snippets.htmlCommand-line interfacealectryon [-h] […]
          [--frontend {coq,coq+rst,coqdoc,json,md,rst}]
          [--backend {coq,coq+rst,json,latex,rst,snippets-html,snippets-latex,webpage,…}]
          input [input ...]Usealectryon--helpfor full command line details.Eachinputfile can be.v(a Coq source file, optionally including reStructuredText in comments delimited by(*| … |*)),.json(a list of Coq fragments),.rst(a reStructuredText document including.. coq::code blocks), or.md(a Markdown/MyST document including{coq}code blocks).  Each input fragment is split into individual sentences, which are executed one by one (all code is run in a single Coq session).One output file is written per input file.  Each frontend supports a subset of all backends.With--backendwebpage(the default for most inputs), output is written as a standalone webpage named<input>.html(forcoq+rstinputs) or<input>.v.html(for plaincoqinputs).With--backendsnippets-html, output is written to<input>.snippets.htmlas a sequence of<preclass="alectryon-io">blocks, separated by<!--alectryon-block-end-->markers (there will be as many blocks as entries in the input list ifinputis a.jsonfile).With--backendjson, output is written to<input>.io.jsonas a JSON-encoded list of Coq fragments (as many as ininputifinputis a.jsonfile).  Each fragment is a list of records, each with a_typeand some type-specific fields.  Here is an example:Input (minimal.json):["Example xyz (H: False): True. (* ... *) exact I. Qed.","Print xyz."]Output (minimal.json.io.json) after runningalectryon--writerjson minimal.json:[// A list of processed fragments[// Each fragment is a list of records{// Each record has a type, and type-specific fields"_type":"sentence","sentence":"Example xyz (H: False): True.","responses":[],"goals":[{"_type":"goal","name":"2","conclusion":"True","hypotheses":[{"_type":"hypothesis","name":"H","body":null,"type":"False"}]}]},{"_type":"text","string":" (* ... *) "},{"_type":"sentence","sentence":"exact I.","responses":[],"goals":[]},{"_type":"text","string":" "},{"_type":"sentence","sentence":"Qed.","responses":[],"goals":[]}],[// This is the second fragment{"_type":"sentence","sentence":"Print xyz.","responses":["xyz = fun _ : False => I\n     : False -> True"],"goals":[]}]]The exit code produced by Alectryon indicates whether the conversion succeeded:0for success,1for a generic error, and10+ the level of the most severe Docutils error if using a Docutils-based pipeline (hence10is debug,11is info,12is warning,13is error, and14is severe error).  Docutils errors at levels belowexit_status_level(default: 3) do not affect the exit code, so level10,11, and12are not used by default.As a libraryUsealectryon.serapi.annotate(chunks: List[str]), which returns an object with the same structure as the JSON above, but using objects instead of records with a_typefield:>>>fromalectryon.serapiimportannotate>>>annotate(["Example xyz (H: False): True. (* ... *) exact I. Qed.","Check xyz."])[# A list of processed fragments[# Each fragment is a list of records (each an instance of a namedtuple)Sentence(contents='Example xyz (H: False): True.',messages=[],goals=[Goal(name=None,conclusion='True',hypotheses=[Hypothesis(names=['H'],body=None,type='False')])]),Text(contents=' (* ... *) '),Sentence(contents='exact I.',messages=[],goals=[]),Text(contents=' '),Sentence(contents='Qed.',messages=[],goals=[])],[# This is the second fragmentSentence(contents='Check xyz.',messages=[Message(contents='xyz\n: False -> True')],goals=[])]]The results ofannotatecan be fed toalectryon.html.HtmlGenerator(highlighter).gen()to generate HTML (with CSS classes defined inalectryon.css).  Passhighlighter=alectryon.pygments.highlight_htmlto use Pygments, or any other function from strings todominatetags to use a custom syntax highlighter.As a docutils or Sphinx moduleWith blogs (Pelican, Nikola, Hugo, etc.)Include the following code in your configuration file to setup Alectryon’sdocutilsextensions:importalectryon.docutilsalectryon.docutils.setup()This snippet registers a.. coq::directive, which feeds its contents to Alectryon and displays the resulting responses and goals interleaved with the input and a:coq:role for highlighting inline Coq code.  It also replaces the default Pygments highlighter for Coq with Alectryon’s improved one, and sets:coq:as the default role.  Seehelp(alectryon.docutils)for more information.To ensure that Coq blocks render properly, you’ll need to tell your blogging platform to includealectryon.css.  Using a git submodule or vendoring a copy of Alectryon is an easy way to ensure that this stylesheet is accessible to your blogging software.  Alternatively, you can usealectryon.cli.copy_assets.  Assets are stored inalectryon.html.ASSETS.PATH; their names are inalectryon.html.ASSETS.CSSandalectryon.html.ASSETS.JS.By default, Alectryon’s docutils module will raise warnings for lines over 72 characters.  You can change the threshold or silence the warnings by adjustingalectryon.docutils.LONG_LINE_THRESHOLD.  WithPelican, use the following snippet to make warnings non-fatal:DOCUTILS_SETTINGS={'halt_level':3,# Error'warning_stream':None# stderr}I test regularly with Pelican; other systems will likely need minimal adjustments.With SphinxFor Sphinx, add the following to yourconf.pyfile:extensions=["alectryon.sphinx"]If left unset in your config file, the default role (the one you get with single backticks) will be set to:coq:.  To get syntax highlighting for inline snippets, create adocutils.conffile with thefollowing contentsalong yourconf.pyfile (seebelowfor details):[restructuredtext parser]
syntax_highlight = shortSetting optionsVarious settings are exposed as global constants in the docutils module:alectryon.docutils.LONG_LINE_THRESHOLD(same as--long-line-threshold)alectryon.docutils.CACHE_DIRECTORY(same as--cache-directory)alectryon.docutils.CACHE_COMPRESSION(same as--cache-compression)alectryon.docutils.HTML_MINIFICATION(same as--html-minification)alectryon.docutils.AlectryonTransform.SERTOP_ARGS(same as--sertop-arg)Controlling outputThe.. coq::directive takes a list of space-separated flags to control the way its contents are displayed:One option controls whether output is folded (fold) or unfolded (unfold).  When output is folded, users can reveal the output corresponding to each input line selectively.Multiple options control what is included in the output.
-in: Include input sentences (no-in: hide them)
-goals: Include goals (no-goals: hide them)
-messages: Include messages (no-messages: hide them)
-hyps: Include hypotheses (no-hyps: hide them)
-out: Include goals and messages (no-out: hide them)
-all: Include input, goals, and messages (none: hide them)
-fails(for sentences expected to throw an error): Strip theFailkeyword from the input and remove theThe command has indeed failed with message:prefix in the output. (succeeds: leave input and output as-is)The default isall fold, meaning that all output is available, and starts folded.  The exact semantics depend on the polarity of the first inclusion option encountered:x y zmeans the same asnone x y z, i.e. includex,y,z, and nothing else;no-xno-ymeansallno-xno-y, i.e. include everything exceptxandy.These annotations can also be added to individual Coq sentences (⚠sentences, not lines), using special comments of the form(* .flag₁ … .flagₙ *)(a list of flags each prefixed with a.):..coq::Require Coq.Arith. (* .none *)             ← Executed but hiddenGoal True. (* .unfold *)                   ← Goal unfoldedFail exact 1. (* .in .messages .fails *) ← Goal omittedFail fail. (* .messages .fails *)        ← Error message shown, input hiddenMore precise inclusion/exclusion is possible using themarker-placement mini-languagedescribed below.  For example:-.h(Inhabited)Hide all hypotheses that mentionInhabited-.g#2.h#IHnHide hypothesisIHnin goal 2.-.g#2.h#*Hide all hypotheses of goal 2.-.h#*.h#IHnShow only hypothesisIHn-.g#*.g#1 .g#3 .g{False}Show only goals 1, 3, and any goal whose conclusion isFalse.Finally, you can use a[lang]=…annotation to chose which Pygments lexer to use to render part of a goal:.msg[lang]=haskellHighlight the bodies of all messages produced by this sentence using the Haskell lexer.These last two features are experimental; the syntax might change.Referring to subparts of a proof (the marker-placement mini-language)Each object in a proof (sentences, goals, messages, hypotheses, conclusions) can be referred to by giving a path that leads to it, written in CSS-inspired notation.  This makes it possible to selectively show, hide, or link to parts of the proof state.In the example below, the markers[α],[β], and[γ]correspond to the paths listed below:Goal∀mn,m+n=n+m.[α]inductionm;intros.-(* Base case *)【n:ℕ⊢0+n=n+0[β]】applyplus_n_O.-(* Induction *)【m,n:ℕ;IHm:∀n:ℕ,m+n=n+m[γ]⊢Sm+n=n+Sm】[α].s(Goal ∀)Search for a sentence (.s(…)) by matching its contents.[β].s(Basecase).cclSearch for a sentence (.s(…)) matchingBase case, then match the conclusion (.ccl) of its first goal.[γ].s(Induction).h#IHmSearch for a sentence (.s(…)) matchingInduction, then match the hypothesisIHmby name  (.h#…) in the first goal..s(Induction).g#1.h(m+ n = n + m)Search for a sentence (.s(…)) matchingInduction, select its first goal by number (.g#…), match the hypothesisIHmby searching for its contents (.h(…)).The full architecture of a path is shown below for reference:.io#nameex: .io#introA block of code whose name matchesname.
(.io is optional and defaults to the most recent code block.)

    .s(pattern)                  ex: .s(Goal True)
      Any sentence matchingpattern.
    .s{pattern}                  ex: .s{forall*m*n*,}
      Any sentence that completely matchespattern.

       .in
         The input part of the sentence.

       .msg
         Any message
       .msg(str)                 ex: .msg(Closed under global context)
         Any message whose text includesstr.
       .msg{pattern}             ex: .msg{*[*syntax*]*}
         Any message whose complete text matchespattern.

       .g#idex: .g#1Goal numberid.
       .g#nameex: .g#base_caseThe goal namedname(documentation).
       .g(str)                   ex: .g(True)
         Any goal whose conclusion includesstr.
       .g{pattern}               ex: .g{* ++ * ++ * = *}
         Any goal whose complete conclusion matchespattern.
       (.g is optional and defaults to #1.)

           .ccl|.name
             The conclusion or name of the goal.

           .h#nameex: .h#IHnThe hypothesis namedname.
           .h(str)               ex: .h(Permutation)
              Any hypothesis whose body or type includesstr.
           .h{pattern}           ex: .h{nat}
              Any hypothesis whose complete body or type matchespattern.

               .type|.body|.name
                 The type or body or name of the hypothesis.Plain search patterns (delimited by(…)) are matched literally, anywhere in the term.  Other patterns ({…}patterns and#…names) usefnmatch-stylematching(?matches any character;*matches any sequence of characters; and[]matches a range of characters), and must match the whole term.  Hence:To match hypothesisH1but notH10norIH1, use.h#H1.To match hypotheses of typenat, but not of typelist natornat->nat, use.h{nat}To match hypotheses whole type or body includesPermutationanywhere, use.h(Permutation)or.h{*Permutation*}.Etc.As long as the search term does not contain special characters (*?[]), a plain search ((…)) is the same as an fnmatch-style search with wildcards on both sides ({*…*}).Finally, you can attach  can attach arbitrarykey-valueto subparts of a goal matched using the marker-placement mini-language by appending[key]=valueafter the path.  This is useful with custom transforms and with the[lang]=…setting to customize highlighting for a given sentence or message.This feature is experimental; the syntax might change.Extra roles and directivesFor convenience, Alectryon includes a few extra roles and directives:Markers and marker referencesThe:mref:role (short for “marker reference”) can be used to point the reader to a sentence, a goal, or a hypothesis.  The argument is a search pattern written in themarker-placement mini-language; Alectryon locates the corresponding object in the input sent to the prover or in the prover’s output, inserts a marker at that point, and replaces the reference with a link to that marker.For example, the[γ]marker in the example above could be inserted using:mref:`.s(Induction).h#IHm`or:mref:`.s(Induction).g#1.h(m+ n = n + m)`.By default markers refer to the most recent.. coq::block, but other blocks can be targeted by name by prepending.io#nameto the argument of:mref:.Markers can be customized by setting the:counter-style:option on a custom role derived from:mref:; for example, to use Devanagari numerals:..role::dref(mref):counter-style:० १ २ ३ ४ ५ ६ ७ ८ ९More details and examples are given inrecipes/references.rst.This feature is experimental: the syntax might change.Quoted references to goal fragmentsThe:mquote:role is similar to:mref:, but it inserts a copy of the target instead of a link to it.  Targets may only be hypotheses, goal conclusions, or goal or hypothesis names.For example, using:mquote:`.s(Induction).h#IHm.type`in the example above would print the type ofIHm,∀ n: ℕ, m + n = n + mwhereas:mref:`.s(Induction).g#1.h(m+ n = n +m).name`would produce only the name of the corresponding hypothesis,IHm.An.. mquote:directive is also available.  It places the quoted elements in a block and preserves indentation and newlines, unlike the:mquote:role (whose output appears inline).More details and examples are given inrecipes/references.rst.Output assertionsSometimes it is desirable to check that the prover produced the right output, without displaying that output to the user.  In these cases, Alectryon’s marker-placement mini-language can serve as a poor lad’s unit test.  Themassertdirective takes one argument (a path prefix), and checks that each line of its body is a valid reference to part of a previous goal.More details and examples are given inrecipes/references.rst.Links to Coq identifiers:coqid:can be used to link to the documentation or definition of a Coq identifier in an external file.  Some examples::coqid:`Coq.Init.Nat.even`→Coq.Init.Nat.even:coqid:`Coq.Init.Nat#even`→even:coqid:`apredicate <Coq.Init.Nat.even>`→a predicate:coqid:`Coq.Arith.PeanoNat#`→Coq.Arith.PeanoNat:coqid:`alibrary<Coq.Arith.PeanoNat#>`→a library:coqid:`Coq.Arith.PeanoNat#Nat.Even`→Nat.Even:coqid:`apredicate <Coq.Arith.PeanoNat#Nat.Even>`→a predicateBy default,:coqid:only knows how to handle names from Coq’s standard library (that is, names starting withCoq., which get translated to links pointing tohttps://coq.inria.fr/library/).  To link to other libraries, you can add entries toalectryon.docutils.COQ_IDENT_DB_URLS, a list of tuples containing a prefix and a templated URL.  The URL can refer to$modpath, the part before the last#or.in the fully qualified name, and$ident, the part after the last#or..  Here is an example:("My.Lib", "https://your-url.com/$modpath.html#$ident")Alternatively, you can inherit from:coqid:to define new roles.  The following defines a new:mylib:role, which assumes that its target is part ofMy.Lib:.. role:: mylib(coqid)
   :url: https://your-url.com/My.Lib.$modpath.html#$identCachingThealectryon.jsonmodule has facilities to cache the prover’s output.  Caching has multiple benefits:Recompiling documents with unchanged code is much faster, since Coq snippets do not have to be re-evaluated.Deploying a website or recompiling a book does not require setting up a complete Coq development environment.Changes in output can be inspected by comparing cache files.  Caches contain just as much information as needed to recreate input/output listings, so they can be checked-in into source control, making it easy to assess whether a Coq update meaningfully affects a document (it’s easy to miss breakage or subtle changes in output otherwise, as when using the copy-paste approach or even Alectryon without caching).To enable caching on the command line, chose a directory and pass it to--cache-directory.  Alectryon will record inputs and outputs in individual JSON files (one.cachefile per source file) in subdirectories of that folder.  You may pass the directory containing your source files if you’d like to store caches alongside inputs.From Python, setalectryon.docutils.CACHE_DIRECTORYto enable caching.  For example, to store cache files alongside sources in Pelican, use the following code:import alectryon.docutils
alectryon.docutils.CACHE_DIRECTORY = "content"With a custom driverFor advanced usage, or to customize Alectryon’s command-line interface, you can use a custom driver.  Create a new Python file, and add the following to it:fromalectryonimportcli…Anyextensioncodeherecli.main()Extensions might include, registering additional docutils directives or roles withdocutils.directives.register_directiveanddocutils.roles.register_canonical_role, adding custom syntax highlighting for project-specific tokens usingalectryon.pygments.add_tokens, or even tweaking the operation of the Coq lexer inalectryon.pygments_lexer, or monkey-patching parts of Alectryon’sdocutilsmodule.Seerecipes/alectryon_custom_driver.pyfor a concrete example.TipsPrettificationProgramming fonts with ligatures are a good way to display prettified symbols without resorting to complex hacks.  Good candidates includeFira CodeandIosevka(with the latter, add.alectryon-io{font-feature-settings:'XV00' 1; }to your CSS to pick Coq-specific ligatures).Passing arguments to SerAPIWhen using the command line interface, you can use the-I,-Q,-Rand--sertop-argflags to specify custom SerAPI arguments, like this:alectryon -R . Lib --sertop-arg=--async-workers=4When compiling reStructuredText documents, you can add custom SerAPI arguments in a docinfo section at the beginning of your document, like this::alectryon/serapi/args:-R . Lib -I mldirTo set SerAPI’s arguments for all input files, modifyAlectryonTransform.DRIVER_ARGS["sertop"]inalectryon.docutils.  Here’s an example that you could use in a Sphinx config file:from alectryon.docutils import AlectryonTransform
AlectryonTransform.DRIVER_ARGS["sertop"] = ["-Q", "/coq/source/path/,LibraryName"]Note that the syntax ofDRIVER_ARGS["sertop"]is the one ofsertop, not the one ofcoqc(https://github.com/ejgallego/coq-serapi/issues/215).Adding custom keywordsYou can usealectryon.pygments.add_tokensto specify additional highlighting
rules, such as custom tactic names.  Seehelp(alectryon.pygments.add_tokens)for more details.When compiling reStructuredText documents, you can add per-document highlighting rules to the docinfo section at the beginning of your document, like this::alectryon/pygments/coq/tacn:intuition_eauto simplify invert:alectryon/pygments/coq/tacn-solve:map_tauto solve_eqInteractivityMost features in Alectryon’s HTML output do not require JavaScript, but extra functionality (including keyboard navigation) can be added by loadingassets/alectryon.js(this is done by default).Scripts needed to unminify documents produced with--html-minification(seebelow) are bundled into the generated HTML and do not need to be loaded separately.Authoring supportTheetc/elispfolder of this directory includes an Emacs mode,alectryon.el, which makes it easy to switch between the Coq and reStructuredText views of a document.Docutils configurationYou can set Docutils settings for your single-page reST or Coq+reST documents using adocutils.conffile.  See thedocumentationor theexampleinrecipes/.  For example, the following changeslatex-preamblefor the XeTeX backend to custom fonts:[xetex writer]
latex-preamble:
  \setmainfont{Linux Libertine O}
  \setsansfont{Linux Biolinum O}
  \setmonofont[Scale=MatchLowercase]{Fira Code}You can also use theDOCUTILSCONFIGenvironment variableto force alectryon to use a specific configuration file.Reducing page and cache sizes (experimental)Proofs with many repeated subgoals can generate very large HTML files and large caches.  In general, these files compress very well — especially with XZ and Brotli (often over 99%), less so with GZip (often over 95%).  But if you want to save space at rest, the following options may help:--html-minification:  Replace repeated goals and hypotheses in the generated HTML with back-references and use more succinct markup.  Minimal Javascript is included in the generated page to resolve references and restore full interactivity.  Typical results:4.4M List.html          24.8M Ranalysis3.html
1.4M List.min.html       452K Ranalysis3.min.html--cache-compression: Compress caches (the default is to use XZ compression).  Typical results:3.2M List.v.cache       21M Ranalysis3.v.cache
 66K List.v.cache.xz    25K Ranalysis3.v.cache.xzFrom Python, usealectryon.docutils.HTML_MINIFICATION = Trueandalectryon.docutils.CACHE_COMPRESSION = "xz"to enable minification and cache compression.A minification algorithm for JSON is implemented injson.pybut not exposed on the command line.Diffing compressed cachesCompressed caches kept in a Git repository can be inspected byautomatically decompressing thembefore computing diffs:# In $GIT_DIR/config or $HOME/.gitconfig:
[diff "xz"]
  binary = true
  textconv = xzcat

# In .gitattributes:
*.cache.xz diff=xzBuilding without SerAPIAlectryon can compile documents usingcoqc.  Sentences be split correctly, but goals and messages will not be collected, and error reporting will be less precise.  To use this feature, pass--coq-driver=coqc_timeto Alectryon.Building without AlectryonThealectryon.minimalPython module provides trivial shims for Alectryon’s roles and directives, allowing you continue compiling your documents even if support for Alectryon stops in the future.Including custom JS or CSS in Alectryon’s outputFor single-page documents, you can use a.. raw::directive:..raw::html<script src="https://d3js.org/d3.v5.min.js" charset="utf-8"></script><script src="https://dagrejs.github.io/project/dagre-d3/latest/dagre-d3.js"></script><link rel="stylesheet" href="rbt.css"><script type="text/javascript" src="rbt.js"></script>For documents with more pages, you can either move the.. rawpart to a separate file and.. includeit, or you can use a custom driver: create a new filedriver.pyand use the following:importalectryon.htmlimportalectryon.clialectryon.html.ADDITIONAL_HEADS.append('<link rel="stylesheet" href="…" />')alectryon.cli.main()But for large collections of related documents, it’s likely better to use Sphinx (or some other similar engine).  In that case, you can use Sphinx’ built-in support for additional JS and CSS:app.add_js_file(js)andapp.add_css_file(css).Special case: MathJaxMathJax is a JavaScript library for rendering LaTeX math within webpages.  Properly configuring it can be a bit tricky.If you just want to include math in reStructuredText or Markdown documents, docutils will generally do the right thing: it will generate code to load MathJaX from a CDN if you use the:math:role, and it leave that code out if you don’t.If you want to render parts of your Coq code using MathJaX, things are trickier.  You need to identify which text to render as math by wrapping it into\( … \)markers; then add themathjax_processclass to the corresponding document nodes to force processing (otherwise MathJax ignores the contents of Alectryon’s<pre>blocks); then trigger a recomputation.  See./recipes/mathjax.rstfor an example and a more detailed discussion.GalleryPierre Castéran,Hydra Battles and Cie(PDF, using a customAlectryon driverto render snippets extracted from a large Coq development).Enrico Tassi,Tutorial on the Elpi programming language(using acustom Alectryon driverto highlight mixed Coq/ELPI code).Anton Trunov.Introduction to Formal Verification course at CS Club.Jean-Paul Bodeveix, Érik Martin-Dorel, Pierre Roux.Types Abstraits et Programmation Fonctionnelle Avancée.Li-yao Xia.Tutorial: Verify Haskell Programs with hs-to-coq.Silver Oak contributors.Formal specification and verification of hardware, especially for security and privacy.Philip Zucker.Translating My Z3 Tutorial to Coq.Li-yao Xia.hakyll-alectryon: Hakyll extension for rendering Coq code using Alectryon.