This document specifies the AsciiMath notation as implemented by Plurimath:

• the token surface: symbols, numbers, function names, fonts, fences;

• the construct shapes: unary, binary, ternary and sub/sup classes, with their arguments;

• tables and their bracket forms;

• scripts and fractions, with the precedence that joins them;

• quoted strings and the UnitsML channel;

• the uncertainty forms of PM 1002 as they read and write in AsciiMath;

• precedence and grouping;

• the reading algorithm and its errors;

• the corpus and conformance.

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.

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.

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

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

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.

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.

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

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.

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.

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.

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.

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).

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.

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

1. sum — the ternary token; its scripts follow;

2. _(i=1) — the lower limit: an index definition i = 1 (evaluation reads it per PM 1004; the tree carries the limit as written);

3. ^n — the upper limit: the name n;

4. i^3 — the summand: a power;

5. = — the relation symbol;

6. ${\left(\frac{n(n+1)}{2}\right)}^2$((n(n+1))/2)^2 — the right side: a power over a fenced fraction — the inner fence holds the product n(n+1), the fraction takes the fence and the 2, the outer fence groups the fraction, and ^2 scripts it all.

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.

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.

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.

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.

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.

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.

Text enters the notation in two forms:

• text(content) — the text function: the content reads as upright text, and AsciiMath commands inside it are honoured (text(the "sum" is) reads its quotes as text);

• quoted strings — "content" — read verbatim with the channel exception of clause 11.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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).

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.

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.

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:

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.

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.

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.

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.

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).

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.

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.

^ 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.

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.

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)$((n(n+1))/2) 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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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$((n(n+1))/2)^2 scripts the whole fenced fraction. Grouping is the author’s precedence tool and always wins.

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.

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).

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”.

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.

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.

−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.

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.

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.

The reader proceeds in four stages:

1. Tokenise. The input splits into tokens by longest match against the constants: construct names and fonts first (longest name wins), then symbol tokens, then numbers, then structure characters, then fences. A character sequence matching nothing is a reading error with its position.

2. Resolve. Tokens resolve through the constants’ classification: unary, binary, ternary, sub/sup, font, special alphabet, symbol, number, fence, structure.

3. Build. The construct tree builds by the precedence of clause 13: classes take their arguments (parenthesised or adjacent), scripts attach, fractions bind, operators fold.

4. Validate. Uncertainty nodes construct through PM 1002’s validation; the tree yields.

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.

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.

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.

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

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.

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

1. tokenise: the construct name, its fence, the number tokens, the channel string, the plus, the name;

2. resolve: uexp is a construct with its fixed arity; the channel matches;

3. build: the call takes four arguments; the channel is the unit operand following per PM 1002’s placement; the addition joins the uncertainty node and x as operands;

4. validate: the uncertainty node constructs through PM 1002 — category expanded, fields complete, factor positive, probability in range.

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

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.

• (: opens an angle fence only where a fence can open — inside a construct argument it is still a fence; the construct’s argument grammar wraps it.

• (( is two opens, not one special token; the table recognition of clause 9 happens at the construct-argument level.

• 2.10 is one number; 2.1.0 is a number then a fault; .. is two faults in a row and the reader reports the first.

• The reader is Unicode-native: symbol tokens are Unicode where the registry says so, and the letter-pair fences are ASCII. A lookalike character (a fullwidth parenthesis for () is an unresolvable run, named and positioned.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Fences nest: $\left(\begin{array}{c}a\\ b\end{array}\right)$((a),(b)) 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.

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.

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.

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.

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

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.

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.

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.

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

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.

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.