# Changelog All notable changes to imprimatur are recorded here. Versions follow [semantic versioning](https://semver.org/). ## Unreleased - Three defects the sweep's judge of equivalence found (imprimatur-paper `sweep/judge.py`), each a rendering the read-back cannot fault, since its grammar is the renderer's own, but a reader would: an instance binder `[Fintype V]`, `[Group G]` or `[Field k]` left out of the prose, which generalises the statement; `(\log N)^{-c}` printed as `\log N^{-c}`; and an `∃` over a proof printed as a vacuous "there is h". Now: the `mathlib` pack writes the common classes as sentences ("V is finite", "G is a group", "M is an R-module", …) and `core` writes `Nonempty`, so their instance binders are hypotheses; an instance binder whose class is in `Prop` with one field and no rule is that field's statement (`[NeZero n]` as `n ≠ 0`, `[Fact p]` as `p`), where before it was left out; the pack's prefix functions (`\log`, `\exp`, `\sin`, `\cos`, `\log_b`, `\Re`, `\Im`, `\deg`) are at precedence 72, below `^`, so `(\log N)^{2}` keeps its parentheses; `∃ h : p, q`, over a proof the body does not mention, is `p ∧ q`, in the prose view's "there is … such that" too; and division of natural numbers, which rounds down, is written `⌊a/b⌋` with the fraction stacked, where before `n^2 / 4` read as a fraction (a `different` verdict of the judge); stacked, so that it is not also read as the floor of a real division, `⌊a / b⌋`, which a cast operand would allow. For the read-back, the arithmetic rules are homogeneous in sort (`a + b` is of its operands' sort). - A `mathlib` notation pack (#36), on by default with the other four, from a sweep of the 4,907 statements of google-deepmind/formal-conjectures through the `math` and `prose` views (2026-11-21): the Mathlib constants left bare most often that a rule can write without a choice the paper would want to make, and without a pun in the read-back. `ℝ`, `ℂ`, `ℤ/nℤ`; coercions from bundled functions and from `ℚ`, `ℝ≥0`, `ℕ+`, `ℝ` to `EReal`, not shown; `log`, `exp`, `√`, `π`, trigonometry, `ℜ`, `ℑ`, absolute value and norm, factorials, binomials, `φ`, `π(n)`, floors and ceilings; cardinalities; sentences for primality, parity, irrationality, finiteness, monotonicity, coprimality, connectedness; congruences of integers; intervals, set-builder notation, filtered finsets; sums, products and series; limits and "for all sufficiently large" along `atTop`; graph invariants; polynomial evaluation and degree. The `core` pack gains `ℚ`, `∣`, gcd and lcm, injective and surjective; `sets` gains `{a, b}` and `insert a s` as `{a} ∪ s`. A pack rule whose constant the environment lacks is dropped when the rules are assembled, so the packs cost a project nothing it does not use. The `MathlibPack` fixture stubs the constants, so every rule has a golden use with no Mathlib. For the read-back, a pack rule may give a hole or a result the sort `!`, any datum: neither a universe nor a function type (DESIGN §18.3). The sides of `∣` are data, so `{p ∣ q}` does not also read as the singleton of `p` dividing the proposition `q`. - A key with a component that is not an identifier, written `«…»` as Lean writes it (`Arxiv.«0805.3777».isMaxRank_three`, `ErdosProblems.«1000»`), is read as Lean reads it. Before, the key was split at every dot, and the extractor reported no declaration of that name; 124 statements of formal-conjectures were lost so. - A λ whose body is a `match` on its own variable with one alternative, `fun p => match p with | (a, b) => e`, is written with the pattern for its binder, `\lambda (a, b).\, e`, in the notation in scope, under either `pattern_matching` style; before, it fell back to Lean's text (all 84 fallbacks of the sweep were of this shape). The read-back's λ form takes a term for its binder as well as a name, so the pattern reads as the pair it is; the same pattern under a rule's binder (`{(a, b) | e}` for `Set.ofPred fun p => match p with | (a, b) => e`) is written so too. A variable a rule's pattern binds (`∑_{i ∈ s} f`) reads back as an atom, a name or a parenthesised pattern, not as an expression such as `n ∈ s`. - An applied constant reads back with the sort of its application, a function from its shown arguments' sorts to its result's, where before its sort was unknown (#90): `|E(G)|` is the cardinality of the finset `E(G)` is, not of a set it might be. Each formula is read in the grammar of the productions whose tokens all occur in it, so a large notation costs a formula only what it could read as. - A first example on a Mathlib host, `examples/riemann` (#137): a note that states the five theorems the Lean archive of 2026-11-20 claims (the Riemann Hypothesis and its generalisation) from a file that restates them over Mathlib with `sorry` for every proof. Three things it needed: the `unfold` modifier, which shows a theorem whose statement is a named proposition (Mathlib's `RiemannHypothesis`) as the proposition rather than its name; an instance binder (`[NeZero N]`) stated as a hypothesis when the notation module writes its class, where before every instance binder was left out; and the `claim` option on a block, inline item or `\leancheck`, under which `check` reports a `sorry` as a warning instead of an error, for a result stated but proved elsewhere. The example's end-to-end test runs only with `E2E_MATHLIB=1`, since Mathlib's cache is several gigabytes. - A `let` or `have` in a statement is unfolded before rendering (#135), so the `math` and `prose` views write what it stands for in the paper's notation, with the metavariable names, and a conclusion under a `let` still comes apart into its conjuncts. Before, the whole subterm fell back to Lean's text. A formula that still falls back to Lean's text, a `match` under the default `pattern_matching := code` say, is now reported by `check` as not validated, naming the text, since the paper's notation does not apply in it and the read-back accepts it unread. - `check` no longer warns that `\LeanSourceRef`, which the index views use for their source links, is an undefined macro: the splicer's list of the macros `imprimatur.sty` defines is regenerated, and the `lint` CI job now fails when the list lacks a macro of `imprimatur.sty` (`scripts/check-std-macros.py`). - The site's code blocks have a copy button (`_includes/head-custom.html`, which the primer theme puts in every page's head), so README's "Try it" block can be copied from the site as from GitHub. - External mode rebuilds a cached extractor that was built from other sources than the running imprimatur (#86): `toolchain install` stamps the cache with a digest of the sources, and `build`, `check` and `show` compare it with the sources at hand, rebuilding (incrementally: the build directory is kept) and saying so, or warning under `--no-install`. A cache shared by several checkouts no longer serves one checkout's renderings to another. - Source links (#122): under a profile with `source_links = "url"`, every block, inline item and `\leancheck` carries its declaration's permalink as `src=`, and `imprimatur.sty` typesets it as a hyperlink when the paper loads hyperref: a theorem's title becomes the link, and anything else gets a small `↗` after it (`\LeanSourceTitle`, `\LeanSourceMark`, `\LeanSourceLine`, redefinable). `src=` follows the commit like `\leanref`: `apply` regenerates it, `check` never reports it stale, and the other profiles remove it. The index views link row by row: the `vocabulary` table's project constants and the `provenance` table's locations are written `\LeanSourceRef{path}{line}{text}`, and the block gets `srcbase=`, the template with the commit, from which each becomes a link. The semantics example has a `public` profile, and the PDF on the site is built with it, so each of its blocks, and each row of its index of notation, links to the Lean on GitHub. - examples/semantics has two or three worked examples in each section, Lean theorems about particular terms (`host/Stlc/Examples.lean`) shown as sentences in an `example` environment: α-equivalent terms, a substitution that avoids capture, a typing derivation and an ill-typed term, a β-reduction and call by value, equivariance at work, a step that preserves the type, and a well-typed open term that is stuck. The fixed names are set in typewriter, since a name written like a metavariable makes every rule ambiguous when read back. - In external mode, `build`, `check` and `show` build the extractor for the host's toolchain when none is cached, saying so on stderr, so a first run needs no `imprimatur toolchain install` (#119); `--no-install` fails instead, for CI that must not compile what it did not ask for. The install is not counted in the export phase `--timing` reports. README's Try it block and the Pages workflow lose the install line. - README opens with "Try it in two minutes": one block of commands from `git clone` to the PDF of examples/semantics, ending with `git diff` of the generated TeX. The Pages workflow runs the block and publishes the PDF at examples/semantics/paper.pdf on the site, so the block is tested on every push to main. The `require` block and the modes moved to "Using it in your own paper". - The repository is a Lake package at its root: the extractor, `extract/lakefile.toml` read from `extract/`, with the metadata Reservoir shows (description, keywords, homepage, licence, README). Reservoir indexes root packages only, and a `require` of the repository without a `subDir` now gets the extractor. `lint/root-package` keeps the root lakefile equal to `extract/`'s. Release binaries of the splicer are no longer part of v0.5.0: it is built from source under its pinned toolchain, and binaries may follow as a convenience (#34, #54). - CI keeps a chart of imprimatur's run time (docs/ci-timing.md): every end-to-end build runs with `--timing`, `scripts/timing-fold.py` folds the files to one line per paper, the nightly appends it to the `timing` branch and redraws `chart.svg` there, every run's summary shows the numbers against the nightly medians, and the nightly fails when a paper takes twice its median. `e2e/con-leche` builds papers/con-leche for its time. The summary shows the parts of each build: the extractor's phases, the stages inside `entries` (cone, axioms, the views), the checker's two halves, and the five slowest entries, views and formulas. - `--timing`'s checker event carries `leanexport_ms` and `check_ms`, the two halves of a verified check that was not kept, and the console summary prints them. - The bundle records the validator's verdict on every view it read back, an empty list when nothing was wrong, where before a clean view left no trace and could not be told from one never read back (`lean`, `meta`, or any view under `validate = false`, which still have no entry). The paper about imprimatur's Figure 1 showed a bundle entry with no verdict in it. `check` is unchanged. DESIGN §18.4. - The model keeps the extractor's two inputs apart: the development `L` (what each key states and proves, and which subterms each view shows) and the notation `N` (how a part is printed, and the grammar it is read back in), `SpliceModel.Development` and `Notation`, in place of `Validated`; the world they present renders by definition as the anatomy says. The one assumption the top-level theorems made of the extractor, `Validated.Prints`, is gone: its layout clauses hold by definition, and its plainness clauses are now checked by the extractor, which decides before writing a `prose` sentence or a `rules` figure that it is plain (`Layout.Prose.plain`, `Rule.plain`, proved to decide the model's `Plain`) and otherwise reports it as not validated (`unfaithful-rendering`: "not plain"). `Development.check_sound` and `paper_true` have no hypothesis about the extractor, and Pollack-consistency now covers the views that show one formula too (`document_pollack_formula`). docs/notation.md, DESIGN §18.4. - `\usepackage[colour]{imprimatur}` colours the `lean` view's tokens as the Lean 4 VS Code theme does, by restyling the semantic macros the view already wraps every token in (docs/views.md). - `papers/con-leche`: con-leche's README as a paper whose Lean statements imprimatur generates, every theorem and definition the README names shown from the built development (external mode), with con-leche checking its own development through `[trust] checker`. The experiment found two extractor faults, fixed: the extractor's own library came first on the module search path, so a host's `Main` module (its executable) was shadowed by the extractor's, and a paper citing the host's `main` got the extractor's (a host directory that holds the shared modules, an `Imprimatur/` with no `Imprimatur.olean`, as the paper about imprimatur's does, still goes after the extractor's own, so as not to shadow its library); and the `lean` view wrote `structure` for a class (now `class`, and `class inductive`). - `[trust] checker = "con-leche"` has the development checked by con-leche, the external checker the Lean toolchain ships from v4.35, verified in Lean to accept only developments that have a set-theoretic model. `build` exports the modules with `leanexport` and runs the checker alongside the extractor; the bundle records the verdict (`checker`, at the top level, since it is on the development as a whole); and `check` reports `unchecked` unless the verdict is *accepted*, with the checker's own line when it declined (a `sorry` anywhere, an axiom beyond Lean's three) or rejected. The verdict is kept in `.imprimatur/checker.json` with a fingerprint of the toolchain, the modules and the `.olean` files, so only a changed development is checked again; `--no-checker` skips it for a run, and the default is off (DESIGN §7.8, docs/trust.md). - The model proves that building settles (`SpliceModel.build_settles`): after `apply`, `check` reports what it reported before less *stale*, so a build answers exactly the stale blocks and leaves what is the bundle's or the authors' to answer (`check_apply`); and a document `check` passes is one `apply` leaves alone (`apply_of_check_nil`). With locality and the fixed point these are the laws of a well-behaved lens, the paper's outline its constant complement. - The paper about imprimatur, `about/`, moves to its own repository, which requires the splice package from this one by git at a pinned revision; the model it presents, `splice/SpliceModel`, stays here. `e2e/about` goes with it, and the scanner's timing gate runs on the semantics example. - The dependency cone and the axioms are computed once per constant for a whole export, not once per entry: a cone's members are memoised as nodes (their canonical text and what the walk follows from them, trusted constants left out), a group's cones are united by a set, and the axioms a constant depends on are kept across entries. LLMbda's paper exports in 21 s instead of 112 s, with the same bundle. The axioms are now walked by imprimatur rather than by Lean's `collectAxioms`, whose per-module table can hold a partial answer for a constant in a cycle (an inductive type whose constructor's type depends on an axiom reported none, while its constructor reported it); the walk keeps no answer that met a cycle in progress, so such a constant now reports its axioms. A custom view that needs a constant's axioms should call `Imprimatur.Axioms.collect`. - `imprimatur build --timing` (and `check`, `accept`, `show`) records where the time goes, in `.imprimatur/timing.jsonl`, and ends with a summary: the splicer's phases; the extractor's load, entries and write; each entry's stages; each view, with the time its context and grammar took; and, when formulas are validated, each formula with its tokens and the parser's steps. The summary names the slowest entries, views and formulas, so that the first thing to make faster is on the console (#85). - A premise that `latex_metavar_convention` hides is no longer lost: the `prose` view binds the variable it names in the predicate, `Let $\val \in \mathit{Val}$` for a hidden `IsValue v`, instead of in its type, and the `conventions` table lists the convention's metavariable with the predicate and the block that shows it. The about paper's Theorem 1.1 read as a stronger theorem than the one proved; it now reads "Let $V \in \mathit{Val}$ and $M \in \mathit{Term}$" (#77). - The about paper's introduction states its results at the top level, each generated from a theorem of the model (`SpliceModel.Summary`): the bundle the extractor writes is true; building rewrites only blocks, once, and leaves nothing stale; and a paper that checks clean against the extracted bundle is true of the development and Pollack-consistent, every block reading only as its key's statement. - A type that is a function type by definition (`Matrix R C α`, `Set α`) is read back as that function type, and a named or applied type is no longer taken for a function. So `Γ(i)` no longer reads as an application of a context, and with typed applications, `\sum_u f(u) \le 1` reads at the one type `f` returns (#90, part 2). A fixture built with an earlier extractor keeps its rules' old sorts until it is rebuilt. - Reading formulas back types applications: `f(a)` and `f\,a` have the function's codomain for their sort when its sort is a function type, where before every application was of unknown sort. A function of a named type or of unknown sort applies as before (#90, part 1). - The paper's model proves what the chain rule costs and why it is there (`SpliceModel.ReadBackChains`): every reading in the parser's grammar is one in the grammar of chains of any length, and the counterexample of docs/coercion-chains.md is a theorem, under a toy algebra: the unbounded grammar reads `g ( x )` two ways, the parser's grammar one. - The renderer and the reader of formulas share one rule for chains of hidden coercions (docs/coercion-chains.md, route A): a chain never stacks two coercions with the same argument sort, nor a cast below a cast, and where the renderer would hide a coercion the rule forbids it now shows it, as a constant applied (`\LeanMathConst{Option.some}\,x`). So a validated formula has no reading but its statement in the grammar of what the renderer prints; before, `g(some(some(some x)))` could print as `g(x)` and validate as another statement. The depth cap and growth budget of route B are gone, and with them its cost: reading back is affordable again on large papers (`IMPRIMATUR_CHAIN_DEPTH` is removed). - Reading formulas back is one total module, `bundle/ReadBack.lean` (tokens, the grammar's symbols, readings as trees, the chart parser, the matcher), with the algebra of sorts as a parameter, and the paper's model proves it sound and complete: every reading the parser returns is a reading in the notation's grammar, every reading in the grammar is among those it returns unless it says it gave up, and so a validated formula has no reading in the grammar but the one it was rendered from (Pollack-consistency, formula by formula and of a document that checks clean; docs/verified-validator.md, docs/pollack-consistency.md). Where the parser gives up is explicit and reported as "not validated": the budget, a reading past the variant cap (now 256; 32 was exceeded silently by formulas of the paper itself), a third reading of a sub-formula dropped, which could before let an ambiguous formula pass as having one reading, a question that comes round to itself, and a list of the notation that takes no token; an ambiguity is reported before any of these. A chain of coercions applies each argument sort once and has no cast below a cast, so a cycle of coercions no longer cuts the search, and the readings a cut lost are found. - The extractor's prose and rules layouts, its formula emitter and the precedence policy of a notation rule's holes are one pure, total module, `bundle/Layout.lean`, copied into both packages (`lint/bundle-copies`), checked by `lint/verified`, and proved of in the paper's model (docs/verified-extractor.md): the prose parser undoes the prose layout, for the whole sentence the extractor writes (labels, *be a type*, numbered conjuncts, *if and only if*, nested *there is*); the figure parser undoes the rules layout; and a prose or rules rendering that reads back shows its statement part by part, where before the rules view was assumed to. The renderer and the validator's grammar call one `Doc.holeNeeds`, so the grammar demands of an argument what the renderer gives it by construction, not by mirroring. `proseView` and `rulesView` now gather what the view says, then lay it out; their output is unchanged. - The splicer's laws and Theorem 1 are proved of the splicer's own code, not only of a model (docs/verified-splicer.md). The scanner, the slot finder and the text kernel are rewritten as total, tail-recursive functions on characters, proved lossless; an ordinary slot merge is the model's `fill`; `apply` rewrites items in place and checks its own output before writing (`unstable-output`, `not-fixed-point`), which fixed a bug where a rendering holding an alias's `\begin` was written and the file could no longer be scanned; and `imprimatur check` is one function, `checkDoc`, of which Theorem 1 is proved. The model moves into the splice package. New checks: `lint/verified` and `lint/axioms`. The audit's trust check now skips only the blueprint `\lean`, not any item named `lean`. - Slots that the authors never edited now follow their defaults. A block with slots records a digest of its slots' default texts in `dflt=`; while its slots still match it, `apply` gives them the new defaults when a docstring changes. Once a slot of the block is edited, all keep their text, and a changed default is reported once (`slot-default`). The first `apply` after upgrading adds `dflt=` to every block with slots. - The bundle is a Lean type, `bundle/Bundle.lean`, of which the file is the JSON: `Bundle (Image TeX) Verdict`, an entry being what a key names, the images of its statement (hashes and views) and the verdict on its proof. Both executables and the paper's model use it (a copy each; `lint/bundle-copies`), and the module says when a bundle is true of a development. The model of the splicer is built on it, and proves that a document which checks clean against a true bundle is true: every block shows a statement Lean proved, rendered, and reads back as it; every `\leancheck` names one by its hash. The about paper presents this, in the PACMPL format, with a running example: a small simply typed λ-calculus, shown as the paper's reader sees it, as its bundle entry, as its world, and under three edits. A group's or display's entry now has a statement hash and a cone, from its members, so `\leancheck{Title}` works. - Fixed: an alias's template no longer rewrites `{key}`, `{label}` or `{title}` inside the generated content (a structure field named `key` became the block's key). The `grammar` view heads a structure without a category by its type's notation, not its constant's name. - Displays (#73): the `clauses` view sets definitions as `lhs ≜ rhs` rows, and `grammar|display` sets inductive types as grammar rows, each with its description as a slot, for one declaration or a `latex_display "Title" := […]`. `imprimatur.sty` gains `LeanDisplay`, `LeanDisplayBox`, `LeanRulesBox`, `\deq` and `\defeqq`. Text after a box with no blank line before it continues the paragraph, unindented. - `latex_notation … break` lets a long rendering break the line before each of a rule's operators. A constant applied only to implicit arguments is no longer reported as a misread. The provenance table wraps long source paths, and `imprimatur.sty` maps `↪` and `↠` and loads `array`. - `imprimatur show KEY [--view VIEW]…` prints one key's renderings, with the problems translation validation found in each, without touching the paper: for working on notation (#32). - `check` warns (`undefined-macro`) when generated content uses a macro that nothing defines: not the document's files, the paper's own packages, the standard set (TeX, LaTeX, amsmath, amssymb, mathpartir, imprimatur.sty), or `known_macros` in `imprimatur.toml` (#27). - Repository layout, build settings, test harness and CI skeleton (M0). - `imprimatur-splice`, the splicer (M1): `scan`, `apply`, `check` (with `--diff`), `strip` and `migrate-slots`. It supports blocks, aliases, `\leaninline`, `\leanref`, `\leancheck`, slots in both forms, checksums that ignore line endings and trailing whitespace, multi-file documents, and `imprimatur.toml`. See [docs/blocks.md](docs/blocks.md). - `imprimatur-export`, the extractor (M2). It renders the `lean` view (the signature, with semantic token macros) and the `meta` view (source location, axioms, `sorry` status, docstring). It imports at the `private` level, so a `sorry` hidden in a `module` file's private proof is found. Bundles are byte-identical across toolchains v4.28.0-rc1 to v4.35.0. See [docs/views.md](docs/views.md). - `imprimatur build` and `imprimatur check` run the whole flow in in-project and sidecar modes. `tex/imprimatur.sty` typesets the result with pdfLaTeX or LuaLaTeX. `examples/minimal` and `examples/sidecar` show both modes. - Trust checks (M3): - dependency cones, `stmtHash` and `sigHash`, the same on every toolchain; - `\leancheck[stmt=…, sig=…]` with drift detection, and `imprimatur accept`; - comparator manifests, with `KEY@challenge` entries; - blueprint `\lean{…}` and `\leanok`. See [docs/trust.md](docs/trust.md). - External mode: `imprimatur toolchain install VERSION`, then `mode = "external"` reads a host project without changing it. `examples/external` shows it. - Notation and typeset mathematics (M4): - `latex_notation`, with `prec`, `width`, `hide`, `variant`, `flatten` and typed `@` patterns, and `latex_metavar`; - the notation packs `core`, `logic`, `sets` and `order`; - the `math` and `prose` views. Notation modules work in every mode. In external mode they are given as files and elaborated by the extractor. See [docs/notation.md](docs/notation.md). - Rules, grammars and the migration of project A (M5): - the `rules` view (mathpartir), with `latex_rules`, `latex_rule_label`, `latex_group`, premise conventions (`latex_metavar_convention`, `latex_hide_premise`), `include`/`exclude`, and the `grammar` view; - theorem modifiers `rule`, `forall`, `def` and `names=full`; - custom views through `@[latex_view]`, with the document's inventory; - `latex_entry` for keys that are titles, and `latex_style` for a paper's conventions (`names := raw`, `applied_variables := call`); - binder patterns in `latex_notation` (`∃ x, p`, `∑' x, f`, `fun x => e`, `p → q`), partial applications, `flatten` of binder chains with `sep`, `assoc`, `when` guards, `latex_metavar … decorated`, and Greek letters as macros; - several notation files in external mode; - `examples/semantics`, a paper on a name-carrying λ-calculus (swapping, α-equivalence and substitution after Pitts, with preservation and progress proved) whose grammar, rules and results are generated, next to hand-written statements checked with `\leancheck`; the `def` view shows equation lemmas with the definition's own variable names; the prose view labels a hypothesis only where the paper refers to it, with `\leanhypref{key}{h}`; - alias options `label`, `repeat_suffix`, `template` and `comment`; - the scanner records which blocks are typeset, reading `\iffalse` and `\newif` switches; blocks that are not are still maintained; and a command being defined (`\NewDocumentCommand\leancheck…`) is not a use; - the parity gate of DESIGN §16 passed byte for byte; project A now builds its papers with imprimatur, keeps the port in its own repository, and has deleted its old exporter; and project B's analysis rules are generated. See [docs/views.md](docs/views.md), [docs/notation.md](docs/notation.md) and [docs/blocks.md](docs/blocks.md). - Correctness (DESIGN §18): what `check` guarantees, and faithful rendering. The extractor reads back every formula it renders, in the grammar of the notation module, with sorts from Lean's types. `imprimatur check` warns (`unfaithful-rendering`) where a typeset formula is ambiguous, showing both readings, or does not read back. A template that drops a pattern variable is a warning. `validate = false` turns the reading back off. Lean's warnings about notation files now reach the user in external mode, at the files' own line numbers. See [docs/notation.md](docs/notation.md#reading-back). - Reading back is typed more precisely, and found three rendering bugs on project B's paper. Sorts carry type arguments (`Option(Label)`); coercions are read with the sorts they make; `latex_notation … synonym` declares two notations for equal things; application is one reading however written. The bugs: an atomic template's edge hole (`#e(#c)`, `#n!`) got no parentheses; an applied variable with a subscript printed `k_{1}_{x}`; and `imprimatur.sty` loaded `amssymb` under acmart, which defines its symbols. Quantifiers may break after their comma, a definition's long right-hand side breaks within its alignment, and a structure's description spans the grammar. A line break after `,\ ` no longer leaves a lone backslash that escapes what follows. A category letter may stand for several types. - Translation validation also reports a variable that prints as another type's category letter (`latex_category`), as `s ::= gen(s)` did in the paper about imprimatur, where `s` was both a segment and a string. - Definitions by cases, as a paper writes them, and fixes found by rendering every definition of project B's development: - `latex_style pattern_matching := cases` writes a `match` as `case d of p ⇒ e | …`, and `lists := literal` writes a list literal as `[a, b]`; - a `case` inside another no longer shows two variables as one (the patterns of `elab(nest D₁ D₂)` printed `nest(d₂, d₂)`): pattern variables take the names the alternative gives them, renamed when in scope, and a λ's binder is renamed likewise (no more `λx.\,λx.`); - an unused binder Lean named is `_`; a λ that binds a proof is not shown, so `if h : c then a else b` is `if c then a else b`; - a constructor a rule writes as its bare argument (`Sum.inl i` as `i`) is shown in a pattern, on the left of an equation or in a `case`; - the generic binders of an equation lemma (`a`, `x✝`) are named after their categories (`latex_category`), or after the definition's own parameters (`R`, `C`, not `T₁`, `T₂`); an author's `a` or `x` is kept; - reading back tells a type from a value: a universe that may be `Prop` is `Sort*`, a type such as `Fin n` written `[n]` is not read as a one-element list, and a pair is of sort `Prod`. - `about/imprimatur-paper.tex`, a paper about imprimatur built with imprimatur. Its theorems, the splicer's laws and Theorem 1, are proved in `about/lean`, a model of the splicer. CI rebuilds and checks it. - `latex_category T A … => "m"` names the category of a type with parameters, and the category check compares such a type at its parameters (#15). - Views that index the document (#16, #18), rendered after every other block so they see the whole document: - `conventions`: each metavariable, the type it ranges over, and where the document first shows it; - `vocabulary`: the notation the document uses, with its Lean constant and a gloss, by default the library's; `scope=project` lists the project's own and `scope=all` both, an index of notation; - `provenance`: each result with its kind, number, source and axioms. Descriptions and glosses are slots. See [docs/views.md](docs/views.md). - `latex_style categories := loose | unique | strict` (#17). Under `unique` a metavariable stands for one type; under `strict` a variable of a category's type is also written with the category's letter and its own subscripts and primes, and variables that then print alike are errors. `imprimatur check` reports these as `error[category]`. See [docs/notation.md](docs/notation.md#metavariables). - Misreads (#19): the renderer builds the reading each formula should have, and a formula whose one reading differs, because the emitter left out parentheses a reader needs, say, is reported as `unfaithful-rendering`. - The paper about imprimatur states what translation validation guarantees and what is trusted, uses strict metavariables, and ends with a generated index of its notation (#20). `examples/semantics` has one too. - `PLAN.md` is retired: remaining work is tracked as GitHub issues, the principles and definition of done are in `CONTRIBUTING.md`, and the test architecture is in `docs/TESTING.md` (#59).