General

This document is the fifth document of the Plurimath specifications series. It specifies the AsciiMath notation as Plurimath reads and writes it: the complete accepted surface — every token, construct, fence and channel — and the rules that turn linear text into the formula tree of PM 1001.

AsciiMath is a linear format for mathematics: plain text, readable and writable without markup, with mathematics’ own conventions for precedence and grouping. Plurimath’s implementation has grown specifics of its own — the uncertainty forms, the UnitsML channel, localized readings — and this document states the whole surface as it is, grounded in the reader’s tables and pinned by the corpus. Where Plurimath’s AsciiMath differs from the asciimath.org public definition, this document says so in the compatibility notes of each clause; the notation specified here is Plurimath’s.

Documents in the series

Maintainers

This document is maintained by the Plurimath project at https://github.com/plurimath/plurimath.

1.1  General

This document specifies the AsciiMath notation as implemented by Plurimath:

This document does not specify: the other formats (PM 1003), the tree (PM 1001), the uncertainty model (PM 1002), evaluation (PM 1004), or the pma notation, which is its own document.

1.2  Relationship to the series

1.3  Compatibility with asciimath.org

Plurimath’s AsciiMath descends from the asciimath.org public definition and extends it. This document specifies Plurimath’s surface; where it extends or sharpens the public definition, the clause says so in a Compatibility note. The compatibility notes are informational; the rules are normative.

1.4  Audience

Implementers of Plurimath and of other AsciiMath processors, authors writing AsciiMath, and tool builders.

1.5  Extensions over the baseline, in one table

Everything else in this document is the baseline as Plurimath reads it — sharpened, tabulated and pinned, but not changed.

5.1  General

Input text is shown verbatim between backticks; trees are shown in the math-zone notation of PM 1001. Tokens are the reader’s lexical units; this document writes them exactly as accepted.

5.2  Examples

Examples carry an Expected outcome paragraph. Where an example names a tree, the outcome names the node classes; where it names an error, the outcome names the error of PM 1003’s Annex A.

5.3  Compatibility notes

Paragraphs beginning Compatibility note compare this surface with the asciimath.org baseline. They are informational; the rules of the clause are normative regardless.

5.4  Tables

The tables of clauses 6 to 12 and the annexes are generated from the reader’s constants, and a mismatch between a table here and the constants fails the build of this document. The tables are the surface.

5.5  The generated tables

The tables of clauses 6 to 12 and Annexes A to D are generated from the reader’s constants and the registry at build time of this document. An edit to the constants that a table here does not reflect fails the build; the tables and the implementation cannot drift apart silently. Edition 1’s tables were generated from the 0.11 series implementation.

6.1  The shape of the language

AsciiMath input is a sequence of tokens. Tokens come from four sources: the symbol space (clause 6), the construct names (clause 8), the structure characters (^, _, /, @, parentheses), and quoted strings (clause 11). Whitespace separates tokens and never means anything by itself.

6.2  A linear format

The notation is linear: no environments, no begin/end pairs, no markup beyond the construct parentheses. Everything is characters. The fences pair by the table of Annex C — including the pairs the public definition lacks and Plurimath adds: the letter-pair fences (: and :) for angle-bracket content and the single-letter Unicode fences.

6.3  What a reading yields

A reading yields one formula tree per PM 1001: node classes with operands in class order, symbols resolved through the registry, uncertainty nodes constructed through PM 1002’s validation. The tree carries nothing about the notation — the same tree can be written from pma, MathML or OMML (PM 1003).

6.4  The reader’s promises

The reader of this notation (PM 1003, clause 8) is total on this surface: every text built from the constructs of this document reads; everything else is a typed error. The corpus of clause 15 pins both directions.

6.5  A first reading, token by token

The sum of cubes, $\sum _{i=1}^n{i}^3={\left(\frac{n(n+1)}{2}\right)}^2$, as the reader sees it:

Expected outcome. one relation between a limited nary and a scripted fraction — the tree PM 1001’s introduction carries, read from characters a mathematician typed without thinking about markup.

6.6  The three extensions over the baseline

Everything in this document that the asciimath.org baseline lacks is one of three extensions, each with its clause: the uncertainty forms (clause 12), the UnitsML channel (clause 11), and the added tokens and fences (clauses 6 and 8, noted per case). The baseline itself — its symbols, constructs, precedence and fences — reads unchanged.

6.7  Whitespace

Whitespace between tokens is a separator and nothing else: it ends attachments (clause 13) and never creates content. Inside construct argument groups, the argument’s own grammar governs. Inside quoted strings, spaces are content verbatim. The reader normalises nothing about the input’s spacing — input_string keeps it — but the tree records structure only.

6.8  Two readings of one habit

Mathematicians write sin 2x meaning sin(2x). The notation reads sin(2) · x (clause 13’s ruling). The gap between habit and ruling is not a defect to patch with a smarter reader; it is the reason grouping exists, and every AsciiMath author learns it once. The ruling is old, public, and pinned by the corpus — this document states it rather than relitigates it.

6.9  The whitespace rules, in one table

6.10  Reading across the series

An AsciiMath tree is a PM 1001 tree: PM 1002’s uncertainty forms read to validated nodes, PM 1003’s reader contract wraps this reader, PM 1004’s evaluator consumes what the tree denotes, and the writer of clause 16 emits PM 1001’s AsciiMath surface. This document is the notation; the series is the system.

7.1  Numbers

A run of digits with an optional decimal point reads as one Number node: 3, 0.5, 42, 2.10. The digits are verbatim — 2.10 keeps its trailing zero (PM 1002’s exact-decimal discipline applies to the tree’s numbers). There is no exponent form, no thousands separator, no sign: a minus is a symbol sibling, and 1e5 reads as the Number 1 followed by the name e5 is refused — e5 is not a token, so the input errors, which is the correct answer for a notation without exponent forms.

7.2  Upright text: the two forms

Text enters the notation in two forms:

Both yield Text nodes; they differ in processing, not in the node. The choice is the author’s: text(...) for text that may contain structure, quotes for literal text.

7.3  Spacing

Whitespace separates tokens and is never content. The spaces the surfaces render come from the constructs, not from the input’s spacing: x+y and x + y read to equal trees, and input_string preserves whichever the author wrote.

7.4  Text in constructs

text(...) inside constructs composes: color(red)(text(urgent)) colours its text; [[a,text(total)]] sits text in a cell. The text content participates in the tree as an operand like any other, and the writer surfaces render it upright per PM 1001.

7.5  The number boundary

A token boundary ends a number: 2x is the number 2 then the name x (an implicit product per clause 13), 2.5.1 is the number 2.5 then a fault, and 1..5 is a number, a fault, a number — the reader does not guess ranges into existence.

7.6  Verbatim, one more time

The exact-decimal discipline (CalConnect 36813, PM 1002) is visible here at the notation’s front door: 2.10 reads to a Number whose text is 2.10, and every writer emits those digits. An author who writes the trailing zero made a precision statement; the notation’s job is to carry it to every surface, and it does.

8.1  The four shapes

The construct classes come in four argument shapes, and every name below belongs to exactly one:

Parenthesised arguments group: sqrt(x+1) takes the whole sum; sqrt x+1 takes only x. The parenthesis form is always available, and adjacency is always available for the last argument of a unary class.

8.2  Unary classes

The complete unary list, from the reader’s constants:

Each reads to its function class of PM 1001’s Annex A: the trigonometric and hyperbolic names to their classes, the accents (bar, dot, hat, vec, tilde, ddot) to the accent classes, the fences (abs, norm, floor, ceil, obrace, ubrace) to their fence classes, cancel to the strike-through class, underline and ul to the underbar forms, and the operator names to upright operator classes.

8.3  Binary classes

8.4  Ternary classes: the nary constructs

sum, prod, int and oint take an operand with optional _/^ scripts as the lower and upper limits: sum_(i=1)^n. Without scripts they read as the plain nary operator; with both they read to the nary class carrying its limits (PM 1001’s nary family).

8.5  Sub/sup classes

lim and log take an operand with optional scripts: lim_(x->0), log_2 x. They read to their classes with the limits attached; a bare lim x is the operator over its operand.

8.6  Font style names

Each applies its variant to the operand (PM 1001’s font styles). rm reads to the upright variant, ii to the italic — the shorthand spellings the implementation carries alongside the math-prefixed ones.

Compatibility note. The public definition carries mathfrak, mathcal, mathbb, mathsf, mathtt, mathbf and the shorthands fr, cc, bb, sf, tt. Plurimath adds rm and ii for the upright and italic readings the set lacked.

8.7  The special bold alphabets

ZZ, RR, QQ, NN, CC read to the double-struck number-set letters — the natural, integer, rational, real and complex number symbols — as single tokens. They are the one place a bare uppercase pair is a token, and the reader’s longest-match resolves them before any two-symbol reading.

Compatibility note. These are a Plurimath addition to the public definition, which writes them as bbZ and kin.

8.8  Adjacency vs parentheses

Every unary class accepts both name(x) and name x; the parenthesised form is unambiguous and the adjacency form takes one operand — sqrt x+1 roots x only. Binary and ternary classes require their parenthesised arguments: frac(a)(b) has no adjacency form, because two adjacency arguments would not be distinguishable. The rule is uniform: one-argument constructs may go bare; multi-argument constructs group.

8.9  Overloading, deliberately absent

No token serves two construct roles: root is always the binary root, never a radical sign; text is always the text function. The reader’s classification is single-valued per token (clause 6), and the notation pays for that simplicity with a few explicit spellings (obrace/ubrace for the braces rather than overloading the accents).

8.10  Worked readings per shape

8.11  What the shapes do not do

No class accepts keyword arguments, optional named forms or arity overloads: a name’s shape is fixed by its class list membership. sqrt cannot take a degree (that is root), frac cannot take three arguments (nesting composes), and no unary class reads a second adjacency operand as part of itself — adjacency after a unary is the notation’s product, always.

8.12  The construct shapes at a glance

One shape per class, from the constants, is the notation’s whole economy: the reader classifies once and the argument grammar follows. The table of the four shapes, the complete class lists of this clause and Annex A, and the corpus’s per-class vectors are three views of one fact. Nothing in this document introduces a construct that is not in the lists, and nothing in the lists is absent from this document.

9.1  The bracket forms

A double-bracketed, comma-separated grid reads as a table: [[a,b,[c,d]]] is a two-by-two matrix — each inner bracket pair is a row, commas separate the cells within it. The delimited variants wrap the grid in a fence, and the fence selects the class:

9.2  Alignment

align and eqarray content carries the ampersand alignment points their input wrote; split and multline preserve line structure. The table node keeps the alignment as data (PM 1001’s table classes), and the writer surfaces emit it per their mappings.

9.3  Cells

A cell’s content is a full expression: [[x^2, text(notes)],[frac(a)(b), sum_(i=1)^n i]] reads all four cells as complete subtrees. An empty cell — nothing between separators — reads to the None node.

9.4  Row and cell rules, precisely

A table grid is a bracketed sequence of bracketed rows: [[row],[row]]. Inside a row, commas separate cells; inside a cell, a full expression goes. The reader allows trailing separators to read as an empty trailing cell — the corpus pins whether it warns — and a row mismatch (two cells in one row, three in the next) reads as written: tables are not square by force.

9.5  The delimited forms, precisely

A grid wrapped in (...) reads to Pmatrix; in {...) — the brace pair of Annex C — to Bmatrix; between bar pairs to Vmatrix; and the cases reading comes from the input form the public definition writes. The delimiters live on the tree as the table class; the writer surfaces re-emit the class’s delimiters, which is why the class matters.

9.6  Alignment, precisely

align and eqarray content uses & for alignment points and \ for line breaks, the grid conventions the public definition carries. The alignment points are data: the table node keeps them, the writer surfaces emit them where their format has alignment (`aligned` in LaTeX, `maligngroup` in MathML per its mapping), and the round trip preserves the count and order of points. A surface without alignment drops them as presentation (PM 1001’s fallback rule).

9.7  Tables inside tables

A cell may carry a grid: ],[c,d]] nests. Nesting depth is unbounded; the corpus carries the two-deep case, and nothing in the reader’s recursion limits applies to it that does not apply to any grouping.

9.8  Tables in the corpus, and what they freeze

The table vectors freeze: each bracket form with a known grid; the alignment forms with their points; the empty-cell reading; the nested grid; and the row-mismatch reading as written. Tables are the notation’s most structure-heavy construct, and the corpus treats them accordingly — a table reading that drops a cell cannot hide.

10.1  Scripts

^ attaches a superscript and _ a subscript to the preceding operand: x^2, x_1, x_1^2. The operand is the preceding group — a token, a parenthesised expression, or a construct’s result — and the script content is the following group. Both orders of sub and superscript on one operand read to PowerBase; a lone script reads to Power or Base.

10.2  Scripts on constructs

Scripts attach to the construct that just closed: sum_(i=1)^n, lim_(x->0), log_2 x. The sub/sup classes read the scripts as their limits; the ternary classes read them as the nary limits.

10.3  Fractions

a/b reads to Frac: the operand before the slash is the numerator, the operand after is the denominator, each being a token or a group. $\left(\frac{n(n+1)}{2}\right)$ shows the idiom — groups on both sides of the slash. The slash binds tighter than addition and looser than scripts: a/b^2 is a over b², and a^2/b is a² over b.

10.4  Precedence interplay

The full precedence is clause 13; this clause states the local rules: scripts bind tightest, then fences and constructs, then fractions, then adjacency, then the operators. The reader’s behaviour is the definition; the corpus pins the contested shapes vector by vector.

10.5  Scripts on fences and constructs, worked

${\left(\frac{n(n+1)}{2}\right)}^2$ — the worked case of clause 5 — and its kin:

10.6  The fraction edge cases

a//b — the double slash — is not a token; the reader sees two slashes and errors. a/b/c is (a/b)/c — fractions chain left-associatively. a/b^2 puts the script inside the denominator: scripts bind tighter than the slash.

10.7  Scripts on scripts

A script’s content may carry scripts: x^(y_1) nests the base inside the exponent. Nesting is unlimited and the tree carries it as written — the parser’s levels describe sibling precedence, not a depth limit. The corpus carries the two-deep and three-deep cases.

10.8  The empty script

x^() — a script with an empty group — reads to a script node with an empty operand: the None node fills the slot, the same construct MathML uses for the empty half of a pair. The author who means “nothing here yet” has a notation; the corpus pins it.

11.1  The quoted string

A double-quoted string reads verbatim as a Text node: no command processing, no entity decoding, no interpretation. Quotes inside a quoted string are escaped by doubling — the corpus pins the exact escape rule the reader applies.

11.2  The channel

One string form is reserved: "unitsml(<expression>)", with no leading or trailing whitespace inside the outer quotes, reads as a Unitsml node carrying the expression (clause 10 of PM 1002’s unit rules apply). The channel is the only way units enter AsciiMath machine-readably.

11.3  Why quotes are literal

The channel’s safety is the literalness: a quoted string never executes a command, so content the writer intends as data cannot become structure. This is what lets uncertainty encodings (PM 1002) place units in the channel — the unit expression is data by construction.

11.4  Escapes, precisely

Inside a quoted string, the only escape is the doubled quote for a quote. Backslashes are literal — a quoted string carries \frac as four characters plus text, never as a command. This is the channel’s contract: verbatim means verbatim, and the corpus carries a string with a backslash, a doubled quote, and Unicode to pin all three.

11.5  The channel’s content grammar

The channel’s expression is the asciiunits content language (CalConnect 36817), read by the unit reader at reading time. The reader’s refusal propagates as a reading error — the channel never stores an expression it could not read, because the unit embedding is constructed, not deferred. A unit the language accepts but the registry lacks symbols for is a unit-reader matter, and its refusal names the missing piece.

11.6  Placement in expressions

A channel string is an operand: it sits in a product (3 "unitsml(m)"), attaches after uncertainty calls (PM 1002), and stands alone as a unit statement. It never opens or closes a construct — quotes inside construct arguments are text unless the argument’s grammar says otherwise (the uncertainty calls accept the channel after the call, not inside its parentheses).

11.7  The channel and PM 1002, in one place

The uncertainty forms place units in the channel (ustd(10.3, 0.2) "unitsml(g)"); the visible placement is the fallback. The channel’s grammar is the unit reader’s, and the channel’s authority is the same as every marker’s in PM 1002: the machine-readable form wins, the visible form is regenerated. Nothing in this clause adds rules — it is where the two documents meet, stated once so no reader has to reconstruct the seam.

12.1  The calls

The uncertainty forms read per PM 1002’s AsciiMath encodings: ustd(v, m), uexp(v, m, k, p), ucov(v, l, u, p, kind) — the three categories with their argument orders, optional arguments omitted without empty positions.

The symmetric spelling reads to the model’s probabilistically-symmetric; the reporting form reads per PM 1002’s reconstruction rule — the digit string at the value’s decimal places, AmbiguousDecimalError where the places cannot match.

12.2  Units on uncertainty

The unit follows in the channel: ustd(10.3, 0.2) "unitsml(g)" carries the unit in the embedding. A unit the reader refuses, written visibly after the call, is accepted as the visible placement (PM 1002’s clause 10); the channel form is preferred and the corpus carries both.

12.3  Shared exponents

The shared-exponent reporting form — the concise form where the exponent digits apply to the value’s magnitude — reads to the concise node with the exact decimal shifts the shared-exponent reading defines. The corpus carries the shared-exponent vectors; the rule they pin is that the shift happens at reading, producing the full magnitude, never at evaluation.

12.4  Contexts and locale

The uncertainty forms are locale-independent in their names (ustd/uexp/ucov are fixed tokens) and locale-sensitive in nothing else. Contexts — the surrounding construct an uncertainty appears in — do not change the reading: the node is the node wherever it sits.

12.5  Errors

The uncertainty reading errors are PM 1003’s: arity faults and unknown kinds are ParseError; the concise place-count mismatch is AmbiguousDecimalError; a node that would violate PM 1002’s field rules refuses at construction with InvalidUncertainty.

12.6  The reporting form in expressions

10.3(2) parses as one uncertainty node, not as 10.3 times (2): the reader recognises the reporting form by its shape — a number directly followed by a parenthesised digit string — and claims it before the adjacency rule could. A genuine product of a number and a parenthesised number, 2(3), is therefore also read as the reporting form’s shape — and refused, because 2(3) cannot reconstruct (the digit string 3 at zero decimal places against a value with none — the corpus carries the vector). The author who means the product writes 2*(3).

Compatibility note. The reporting form is a Plurimath extension; the baseline reads 10.3(2) as an adjacency product. The extension is what PM 1002’s concise notation needs, and the corpus carries both the acceptance and the refusal vectors.

12.7  Reading the forms in context

Uncertainty nodes compose: (uexp(10.3, 0.5, 2) + uexp(4.1, 0.2, 2)) "unitsml(g)" is an addition of two expanded nodes — evaluation refuses it per PM 1004’s clause 12 until propagation exists, but reading and rendering carry it faithfully. The uncertainty forms are content, and everything this document says about composition applies to them.

12.8  The complete reading table

12.9  The refusals, complete

2(3) deserves its note: the reporting-form recognition precedes adjacency (clause 12), so a number directly followed by a parenthesised number is claimed as the reporting form and refused on reconstruction. The author who means a product writes 2*(3); the corpus carries the pair.

12.10  Why the uncertainty forms read here

The uncertainty forms are AsciiMath extensions because uncertainty must be writable in a linear format: a laboratory reporting results in AsciiMath needs to state 10.3(2) and have it survive. PM 1002 defines what the node means; this clause defines what the text does; PM 1003 wraps the pair in the reader contract. Three documents, one form, each stating its layer — the seam is deliberate and tested by the shared corpus.

13.1  The chain

Precedence, tightest first:

Each level binds tighter than the ones below it; the construct parentheses of level 1 override everything. The reader’s behaviour is the definition, and the corpus pins the contested shapes explicitly — every row of the table has vectors where the levels interact.

13.2  Groups override

Parentheses group an expression into one operand: x^(2+1) scripts the whole sum; sqrt(x+1) roots the whole sum; ${\left(\frac{n(n+1)}{2}\right)}^2$ scripts the whole fenced fraction. Grouping is the author’s precedence tool and always wins.

13.3  Ambiguity is resolved, never negotiated

Where two readings are conceivable, the rules above decide — the reader does not pick the “intended” reading. The classic cases, with their rulings:

An author who means something else groups. This is the notation’s contract with its users, and every row here is a corpus vector.

13.4  Spaces end attachments

Whitespace after a script or argument ends the attachment: x^2 y scripts only the 2; sum_(i=1)^n i^3 ends the nary’s limits before the summand. Spaces are otherwise insignificant (clause 7).

13.5  Unary application, precisely

name x applies the unary to the adjacency operand — one token, or a group. sin x y is sin(x) times y; sin xy is sin(x) times y as well — the adjacency operand is one token, never a run. sin (x y) is the sine of the product. The corpus carries the three; the ruling is always “one operand, then adjacency”.

13.6  Relations and their low binding

Relations bind loosest: a = b + c relates the whole sum. Chains — a = b = c — fold left as the relation evaluation of PM 1004 defines. A relation inside scripts or arguments is fine where grouping puts it: x->0 inside lim_(...) is the limit’s lower script content, read as the arrow token, not the relation level’s property.

13.7  The whitespace rule’s edge

A space inside construct parentheses is content spacing: sqrt( x + 1 ) reads identically to sqrt(x + 1) — the construct’s argument grammar, not the token grammar, governs inside. The whitespace-ends-attachment rule of clause 13 applies between tokens, not inside argument groups.

13.8  The whole precedence, worked twice more

−x^2 — unary before power? The power binds tighter: the tree is −(x²), the negation applied to the power. An author who means (−x)² groups: (−x)^2. The corpus carries both.

2^-3 — refused: the script content starts with a bare operator (clause 13’s ruling table). 2^(-3) reads. 2^−3 with the Unicode minus reads too — the tokeniser classifies the Unicode minus as the minus symbol, and the grouped script takes it.

a/b c d — the fraction takes b (one token), then adjacency multiplies by c and d in sequence: (a/b) · c · d. Nothing about the slash reaches past its operand.

13.9  The rule behind the rulings

One rule generates the table: each construct and operator takes the smallest operand the grammar allows, and grouping is the only way to offer it more. Every ruling above is that rule applied; an author who internalises it needs no table. The table exists for implementers and for the corpus.

13.10  The one-rule summary, once more

Smallest operand, unless grouped. Every precedence question in this notation resolves to it: the fraction takes a token unless you group; the script takes a token unless you group; the unary takes a token unless you group; the nary’s scripts take tokens unless you group. The reader has no other source of ambiguity, and grouping is always available. This is the clause most authors need, and it fits in one line.

14.1  The stages

The reader proceeds in four stages:

The stages are separable only in description; the implementation interleaves them. What this document pins is the outcome: the tree a given input yields, and the error a malformed input raises.

14.2  Longest match

Longest match is the tokeniser’s rule and the disambiguator: `==> ` is one arrow; <= is one relation; (: opens an angle fence; ZZ is the number-set token before Z could be a symbol. Construct names match before symbols share their letters — sum is the nary construct even though a symbol could begin with s.

14.3  The fences

Fences pair per Annex C’s table. The pairing is by token: an opener matches its own closer, and nesting tracks the open stack. The unpaired cases — an opener without its closer, a closer without an opener — are reading errors naming the fence and its position.

14.4  Errors

The reading errors are PM 1003’s, and this notation produces them thus:

14.5  What the reader never does

It never guesses an intent for a malformed input, never skips a faulting token to continue, never normalises digits, never resolves a symbol outside the registry, and never returns a partially built tree. A reading is total or absent.

14.6  A worked reading

uexp(10.3, 0.5, 2, 0.95) "unitsml(g)" + x:

Expected outcome. an addition of an expanded uncertainty (with unit) and a name — reading total, tree valid, ready for any writer.

14.7  Positional accuracy of errors

Every error of clause 14 carries its input position: the tokeniser’s offsets survive into the typed errors, so a caller can point at the offending character. The corpus pins the positions for its error vectors — a refusal without a position is not a conforming refusal.

14.8  Tokenisation’s edge cases, pinned

14.9  Recovery is not a feature

The reader stops at the first fault. A specification of recovery — skip, resync, best-effort — is a specification of a second reader with different guarantees; this document specifies one reader with complete guarantees instead. Applications that want fault tolerance get it by splitting input and reading the pieces; the typed errors with positions make that practical.

14.10  The reader against the writer

The reader of this document and the writer of PM 1001’s AsciiMath surface are one interface’s two halves (PM 1003). The reader is the generous half — the surface is what it accepts, tokens, synonyms and all. The writer is the conservative half — canonical tokens, canonical forms, one encoding per construct. An author may write generously; a writer never does. Round trips pass through both halves and yield equal trees with re-spelled tokens where synonyms were written — the tree is the same even when the text is not.

14.11  The reading algorithm, recited

Tokenise by longest match; resolve through the constants’ classification; build by the smallest-operand precedence with grouping as the override; validate the uncertainty nodes through PM 1002; yield the tree or the typed error with its position. Four stages, one pass, no second chances — the reader’s entire behaviour is this recitation plus the tables, and the corpus is the proof that the recitation is complete.

15.1  The corpus and its generations

The AsciiMath corpus is the pinned corpus of the plurimath testsuite: a frozen set of inputs with their frozen trees and renderings, replayed by digest. A corpus generation is immutable once published; generations extend, never rewrite — the first generation’s 143 cases are present in every later one.

15.2  What the corpus covers

15.3  Provenance

Each entry states its origin: a clause of this series, a defect fix, or a community report. Provenance is the corpus’s memory — a vector’s existence documents that the behaviour was deliberate, and the generation that froze it is named.

15.4  Replay

Replay is byte-identical: the corpus runner computes digests over the trees’ canonical forms and the renderings, and a mismatch is a failure, not a warning. The runner itself is versioned with the corpus generation.

15.5  The corpus and this document

Every rule in this document has at least one corpus vector: the symbol tables (family representatives), the construct tables (each class plain and grouped), the fence table (each pair, nesting, unpaired), the channel (accepted, degraded, refused), the uncertainty forms (every category, notation, kind, unit placement), the precedence rulings (every row of clause 13’s tables), the localization pairs, and every error row. A rule without a vector is a defect in one of the two — and the build of this document checks the correspondence for the generated tables.

15.6  Size and shape

The corpus generation carries its counts: cases per area of the coverage table, per format column, and per error row. The counts are facts about the generation, published with it; a generation that loses coverage in an area is not a successor, it is a different corpus — and this document’s claims follow the generations, so the loss would be visible in the claim, not buried in the set.

15.7  The replay contract

Replay is part of CI, not a ceremony: the runner runs on every change to the implementation, and the digests are checked on every run. The corpus is the fastest way to know that a change moved behaviour, which is precisely its job.

15.8  A generation’s anatomy

One generation, described concretely so the next is judged against something: the case files (input text, expected tree, expected bytes per surface), the manifest (per-area counts, model version, provenance), the runner version, and the digest set. All four travel together; a generation missing any of them is not publishable. The current generation’s counts publish with the repository release that freezes it, and this document’s claims reference that release by name.

15.9  What the corpus is not

It is not a test suite for the implementation’s internals — it never imports code. It is not a sample of convenient inputs — the refusal vectors and the contested-precedence rows are deliberately uncomfortable. And it is not finished — generations append as the surface grows and as the world reports inputs the set lacked; the append-only rule is what makes every generation a permanent, checkable statement about the notation at its time.

16.1  General

Conformance to this document is claimed as the AsciiMath reading and writing classes of PM 1003, discharged per this document’s surface.

16.2  Conformance classes

The reading claim is the demanding one: the surface is total on well-formed input, so a reader’s refusals are as much a part of the claim as its successes — the error vectors are inside the corpus, not beside it.

16.3  Claiming

A claim names the corpus generation. A claim without a generation is not checkable and is not a claim; a claim against an older generation is void for the current one until rechecked.

16.4  The writer’s side of the claim

The writing claim covers the whole surface too: every node family writes, the uncertainty encodings write per PM 1002, the channel writes for expressible units, and the token chosen per entry is the canonical token of the registry. A writer emitting a non-canonical synonym (an arrow alias where the entry’s canonical token differs) still round-trips — but the byte corpus freezes the canonical form, and that is what the write claim replays.

16.5  Editions

This document’s surface changes only at an edition: tokens join the registry per PM 1001’s process, constructs join with their classes and clauses, and the corpus generation pins each edition’s surface. Between editions, nothing moves.

16.6  What conformance means for authors

For an author, the conforming implementations are interchangeable: text written for one reads the same in another, and the corpus is the guarantee. For a tool builder, the claim to look for is read-asciimath against a named generation — and the refusal behaviour is part of what they are buying, because a reader that accepts everything cannot promise anything about what it read.

16.7  The claim, in one sentence

An implementation conforming to this document reads every input built from this surface into the tree of PM 1001, refuses everything else with a typed error and its position, writes the canonical surface back byte-identically to the corpus, and round-trips losslessly — and names the corpus generation that says so.

17.1  General

The construct lists of clause 8, restated with each name’s reading. These are generated from the reader’s constants; a mismatch fails the build.

17.2  Unary classes and their readings

17.3  Binary readings

17.4  Ternary readings

17.5  Sub/sup readings

lim reads to the limit class with optional scripts; log reads to the logarithm with optional base scripts. Both take the operand adjacency gives and the scripts the input writes.

17.6  The unary readings, worked

The last-but-one row is the table’s trap: gcd, lcm, glb, lub, max and min are unary classes in this notation, whatever their arity in mathematics — an author who means gcd(a, b) writes it as a product-adjacency the reader splits, and the corpus pins the split. The comma form is not a two-argument call; grouping composes.

18.1  Font tokens and their variants

18.2  The special bold alphabets

Both spellings exist for the double-struck set: the prefixed form (bbZ) from the public definition and the special token (ZZ). The tokens read to the same registry entries; the corpus pins both spellings in every rendering.

18.3  Fonts in use

bb R and RR read to different nodes — a font style over the letter versus the number-set symbol — and the corpus carries both, because the two readings are the classic confusion the special alphabets exist to end.

19.1  The fence table

The reader’s parenthesis table, normative:

The multi-glyph pairs (ᑕ/ᑐ, ℒ/ℛ) and the letter pair (:/:) are Plurimath’s additions to the public set; the plain three are the baseline’s.

Compatibility note. The public definition also carries the bare : closer; Plurimath’s pairing is strictly two-sided per this table, and a bare closer is a reading error.

19.2  Nesting

Fences nest: $\left(\begin{array}{c}a\\ b\end{array}\right)$ is a parenthesised group containing a comma-adjacent pair — the table-reader sees the grid only in the bracketed forms of clause 9. The open stack tracks pairs by opener identity; the table forms are recognised at their own positions, not by the fence stack.

19.3  Fences as constructs

abs(x), norm(x), floor(x), ceil(x), obrace(x), ubrace(x) are unary constructs, not bare fences: their delimiters come from the construct, and the bare fence characters group without a node of their own. The distinction matters for round trips: a construct’s fence survives (the construct carries it), a bare group’s fence survives as grouping.

19.4  The pairs in use

The bar pair’s dual role (grouping here, Vmatrix delimiter there) is resolved by position: around a bracketed grid it delimits the matrix, elsewhere it groups. The corpus carries both positions.

19.5  Fences and round trips

A bare group’s fence is grouping, and grouping is not a node — so a round trip may re-spell the grouping (parentheses for brackets where the tree allows). The construct fences (abs, norm, and kin) ride their nodes and survive exactly. An author who needs a specific fence in the output uses the construct that owns it; an author who needs only grouping takes the round trip’s re-spelling. The corpus freezes which cases re-spell and which do not.

20.1  The families and their counts

The symbol surface at edition 1, by family, with representative members. The complete token listing is generated from the registry alongside the other tables.

20.2  Tokens with several spellings

Some entries accept more than one token: the arrows carry their ASCII spellings (->, -->) alongside their named ones; the logic tokens carry words (and, or) alongside signs. Every spelling reads to the same entry and writes to the entry’s canonical AsciiMath token — the round trip may re-spell, and the tree does not change.

20.3  What is not a symbol

Digits, the structure characters, the construct names, the font names and the quoted strings are not symbol tokens; the reader’s classification is total and a token belongs to exactly one class. The boundary cases are decided by the constants and pinned by the corpus: e alone is a symbol; e5 is nothing (a reading error); 2e5 is a number followed by an error.

20.4  The smaller families, complete

The largest families (Greek, operators, relations) carry their complete listings in clause 6; the counts in the family table above are the totals the generated listing holds, and this annex repeats only the families small enough to print in full.

21.1  Generations

Generations extend by appending; a generation’s entries are immutable once published, and the digest replay covers all generations on every run.

21.2  Entry provenance

Each entry names its origin: the clause of this document that first required it, the defect it froze, or the report that brought it. The provenance is the specification’s institutional memory: a behaviour with a provenance entry is deliberate, and a proposal to change it must name the entry.

21.3  Where the corpus lives

The corpus is versioned outside this document, pinned by the replay script the implementation carries. This document’s claims name the generation they were checked against; the register’s build checks the naming.

22.1  Symbol vectors (class read-asciimath)

22.2  Construct vectors (class read-asciimath)

22.3  Table vectors (class read-asciimath)

22.4  Script and fraction vectors

22.5  Channel and uncertainty vectors (classes read-asciimath)

22.6  Precedence vectors (class read-asciimath)

22.7  Round-trip vectors (classes write-asciimath, roundtrip-asciimath)