Canonical English

Scope

Canonical English is useful in the formal, bench-level, in-house, neutral, technical, and consultative registers.

It is not intended to be used for the slang register, where deviations from proper grammar are de rigueur.

Limitations

CE resolves syntactic, lexical, and referential ambiguity. It does not encode pragmatics — what an utterance is doing in a situation, beyond the proposition the words literally express. No amount of dictionary sense disambiguation closes that gap.

“Can you open the window?” is grammatically a question about ability. In ordinary use it is usually a request. “That’s interesting.” can be genuine enthusiasm, polite dismissal, sarcasm, surprise, or criticism. Those readings are not further senses of interesting; they are uses of the same proposition.

CE specifies literal propositional meaning and does not attempt to encode pragmatics (In linguistics and the philosophy of language, pragmatics is the study of how context contributes to meaning.). A CE document records the question about ability, and the predication that something is interesting. The request, and the tone, remain outside the language.

Formal-register communication is, by definition, intended to be low-context (i.e., low-pragmatics). The author encodes as much of the situation as possible in the words themselves, so a later reader can recover the assertions without sharing the original physical or social environment. Constraining CE to that register therefore makes the task of embedding context easier, since the gap is already intended to be minimal.

Rule Derivation Methodology

CE derives grammar rules from the Cambridge Grammar of the English Language (CGEL) by Rodney D. Huddleston and Geoffrey K. Pullum (2002) [6], as codified by the CGELBank team [7] [11].

Extending from CGEL, CE derives additional rules empirically, from corpora in which human annotators have already recorded which reading was intended:

• For each example in the corpora for which noah produces a false negative or false positive, language models propose a new grammar rule. This candidate rule is added to the set, and the new linter is backtested to ensure no regression of any previous test cases. A rule that does not regress our test cases while correcting one or more false positives or false negatives is included.
• In this manner, our grammar rules are added by an agentic process, but the actual linter remains deterministic and therefore extremely fast.

A false negative or false positive must be measurable. The requirements-engineering literature distinguishes nocuous from innocuous ambiguity: an ambiguity is nocuous only when readers actually disagree about it. Innocuous ambiguity gets a construal rule; nocuous ambiguity is rejected. The disposition of every rule is therefore an empirical finding rather than an editorial preference.

Ambiguity Removal

Every sentence in CE must parse to exactly one reading under the rule set. The rule set has conventions that are implicit and may assist in clearing up ambiguity.

Coverage of English in the Wild

Most English sentences a native speaker would consider to be “correct” are also judged as passing in CE. However, there is a long tail of somewhat unusual sentences, a few percent of sentences appearing in wild English, that may not pass the current version of CE.

By definition those sentences are considered invalid, although future more sophisticated versions of CE may include them.

Since noah will mark such sentences invalid, authors wishing to conform to CE must rewrite their words until the text conforms.

The set-theoretic framing of this process — ideal CE as a Stewart set, and each CE1.0.x as a computable approximation measured by false positives and false negatives — is on the methodology page.

Benefits

Constraining English to a single, fully specified dialect is more useful than surface consistency alone would suggest.

Most natural-language systems treat English as an open mix of regional variants, spelling systems, punctuation habits, and near-synonyms. That variation is noise for machines. Eliminating it — fixed spelling, fixed number formats (ISO 80000-1 + ISO 8601), fixed preferred terms, epicene they as the unmarked third-person pronoun, CGEL grammar constraints, consistent punctuation — yields something closer to a formal language that still reads as English.

Regional forks of English, with different date and number formats, spelling (colour/color), and vocabulary, present barriers to communication in the guise of reducing friction for local users. Large software companies ship dozens of locale-specific date and number formats, despite ISO having developed standards. CE adheres to ISO [5]. ISO 80000-1 permits either a point or a comma as the decimal marker; CE picks the point, so 3.14 is a number and 3,14 is not. The world benefits from a single English standard without regional variation. Not only do machine protocols benefit from canonical serialization, but humans do as well.

Sense ambiguity is another barrier to communication:

To improve the handling of ambiguity, we advocate for extending redundant, ambiguity-aware annotation protocols (with attention to disagreement) from single-label tasks (e.g. QA, NLI) to complex, sequential outputs like semantic parsing. Improving both zero-shot generalization and data collection would help models capture the full range of utterance interpretations. This could lead to robust, interactive systems in which agents ask for confirmation or clarification on ambiguous examples (Stengel-Eskin & Van Durme, 2023), ultimately improving safety for critical systems.

Useful Applications of Canonical English

• Reliable semantic parsing / knowledge extraction. A closed, well-defined grammar and lexicon means CE can be converted into knowledge-graph triples without further interpretation.
• High-consistency knowledge bases and wikis. Every article, every claim, every date, number, and unit follows the same rules. Machines (and humans) can trust the surface form more. This is valuable for large-scale biographical, historical, or technical wikis where regional drift normally creeps in over time.
• Training-data hygiene and synthetic data generation. Existing corpora can be normalized, or new text generated, so that the result is internally consistent. Downstream models trained on it learn fewer spurious regional correlations.
• Automatic treebanks of paragraphs. noah --parse --to_tree can generate CGEL-style treebanks of paragraphs on a best-effort basis. That is useful to researchers working in the CGEL annotation framework [11], and as a quality-control loop: parse failures and disagreements become candidates for new grammar rules, so later CE versions move closer to the ideal set described on the methodology page.
• A generation constraint that raises prose quality. Because every content lexeme has one sense and every sentence has one structure, grammar that ordinary English cannot check deterministically — parallel structure across bullet items, matching tense and function across coordinated clauses, consistent attachment — becomes decidable. That checker can sit on the output of a language model and reject or rewrite until the text conforms, so the constraint improves the writing, not only the metadata.
• Controlled interfaces for formal systems. Regulations, contracts, scientific claims, technical specifications, or API documentation written in this dialect become easier to validate, diff, version, and machine-check.
• Pivot language for multilingual systems. A standardized English is a cleaner intermediate representation when translating to or from other languages, or when building cross-lingual knowledge graphs.
• Claim verification and fact-checking pipelines. Surface variation is reduced, so matching claims against a knowledge base or against each other becomes more precise.

The output still reads as natural English. The constraints remove the degrees of freedom that create ambiguity and inconsistency, rather than replacing English with an artificial-looking notation.

Document format

CE has two equivalent serializations, ce-linear and ce-tree. Both are equally unambiguous, and both are equally parsable by a computer. They differ only in audience: ce-linear is GFM that humans can read; ce-tree is JSON-LD that tools can walk as a sentence tree. Each is accompanied by a JSON-LD lexicon of all words used, linked to the semantic web.

The sense @id is a dereferenceable Open English WordNet synset IRI for an open-class word, a Wikidata lexeme IRI for a closed-class function word, or a Wiktionary English-section URL for a mark or digit. @context is the w3id.org PURL https://w3id.org/canonical-english/context/v1. That identifier redirects to the hosted JSON-LD context. The identifier contract is in FORMAT.md.

---
{
  "@context": "https://w3id.org/canonical-english/context/v1",
  "@graph": [
    { "@id": "oewn:06645018-n", "form": "hello" },
    { "@id": "oewn:02475618-n", "form": "world" }
  ]
}
---

Hello, world!

{
  "@context": "https://w3id.org/canonical-english/context/v1",
  "@graph": [
    { "@id": "oewn:06645018-n", "form": "hello" },
    { "@id": "oewn:02475618-n", "form": "world" }
  ],
  "linear_content": "Hello, world!",
  "type": "root",
  "children": [
    {
      "type": "paragraph",
      "children": [
        {
          "type": "text",
          "value": "Hello"
        },
        {
          "type": "punctuation",
          "value": ","
        },
        {
          "type": "text",
          "value": "world"
        },
        {
          "type": "punctuation",
          "value": "!"
        }
      ]
    }
  ]
}

Tools

                   draft.md
       plain English, already valid GFM
                       │
                       ▼
┌─────────────────────────────────────────────┐
│ noah-parser                                 │
│                                             │
│ 1. Refuse anything markdownlint rejects.    │
│ 2. Split the text into blocks: paragraphs,  │
│    headings, lists, tables.                 │
│ 3. Parse the blocks in document order, one  │
│    sentence at a time.                      │
└─────────────────────────────────────────────┘
                       │
                       ▼
                document.ce.md
     JSON-LD frontmatter + the same prose
                       │
                       ▼
┌─────────────────────────────────────────────┐
│ noah-linter                                 │
│                                             │
│ 1. Require JSON-LD frontmatter; extract it. │
│ 2. markdownlint the GFM body.               │
│ 3. Does the prose obey the style rules?     │
│ 4. Does the frontmatter match the prose?    │
└─────────────────────────────────────────────┘
                       │
                       ▼
            Pass / Fail / Warnings

Those two programs convert and check a finished draft. Putting a language model in front of the same linter — so the model keeps proposing until the verdict is accept — is the generation loop below.

Implementing CE in a workflow

Natural English is a linear string. The relations it names are a tree, and later a graph. Token-level tagging — part of speech, even a word-sense label on each token — cannot decide attachment: which phrase a preposition modifies, which noun a relative clause restricts. A parser that tries to force arbitrary English into one tree fails on the unbounded edge cases of real text.

CE inverts that job. The generator — a language model, or a human with noah-parser — proposes a .ce.md file. A deterministic linter, noah-linter, answers yes or no. A text is CE only when the linter accepts it, not merely because a model emitted it. On accept, the same document is already a graph: JSON-LD frontmatter plus a single parse, ready for RDF or any later triple store. On reject, the diagnostic goes back to the generator.

              messy English
                    │
                    ▼
           ┌─────────────────┐      CE-nnnn diagnostic
           │ language model  │◄────────────────────────┐
           └────────┬────────┘                         │
                    │ proposed .ce.md                  │
                    ▼                                  │
           ┌─────────────────┐                         │
           │ noah-linter     │─────────────────────────┘
           └────────┬────────┘
                    │ accept
                    ▼
                 valid CE
            ce-linear / ce-tree

That loop can close in two places. Both treat the linter as the gatekeeper. They differ in when the check runs, and in what access they need to the model.

A yes/no specification

Earlier controlled languages such as Attempto Controlled English (ACE) succeeded as mathematics: a sentence that parsed mapped onto first-order logic and then onto OWL or RDF. They did not succeed as authoring languages. The grammar was a constructive recipe — humans had to learn which sentences were in the fragment — and the fragment was often too small for work outside the lab [14]. That is the usual controlled natural language dilemma: formal enough to check, or large enough to write, but not both. The comparison below places CE in that family.

CE is a verdict, not a constructive how-to-write-it grammar. The linter says accept or reject; it does not have to enumerate every sentence it would accept. A later constructive definition may be attempted. Until then, the pair of a language model and a deterministic linter is what makes the language usable: humans keep writing natural English, the model proposes CE, and the linter is the contract. The model is the compiler. The linter is the type checker. Nothing downstream has to guess.

Resolve Ambiguity at the Write Step, Not the Read Step

Uncontrolled English requires the reader to have implicit context in order to recover the meaning of the text. CE instead passes that work to the author, who must commit to exactly one sense of each word, and one URI for each proper name, before the document is transmitted to any reader.

A document-level default is not enough. On SemCor with fine-grained WordNet senses, about 33 percent of ambiguous words take more than one sense within a single discourse, with no meaningful difference across parts of speech [9]. Each occurrence must be committed, not the lemma.

The author already knows which sense they meant at the time of writing, so recording it is cheap. Every later reader has to reconstruct that same fact from context, and pays for it in compute, in latency, and in the risk of reconstructing it wrongly. Done by the author, the work happens once. Left to the readers, it happens once per reader, per reading, indefinitely.

Agent systems make that cost asymmetry unjustifiable. A system prompt, a tool description, a policy, a specification, or a contract is now read thousands or millions of times, mostly by machines, at a measurable cost per read — and every one of those reads re-derives meaning the author already knew and did not record. A large part of what retrieval and embedding pipelines do is guess, probabilistically and repeatedly, at what the writer knew and did not write down.

Recording senses by hand used to cost more than letting readers guess, which justified transmitting ambiguous text. That cost argument no longer holds: noah-parser performs the upconversion mechanically and noah-linter confirms it, so the author’s commitment costs a build step. With that tooling, there is no remaining reason to transmit ambiguous text. Disambiguate once, before the document is sent, rather than requiring every recipient to do it again.

CE does not claim to have solved word sense disambiguation. It moves the problem from the read side to the write side and records the result. A sense chosen once, written into the document, and transmitted with the text can be checked, diffed, and disputed. A sense inferred silently on every read cannot.

Read-time inference is measurably unreliable on the cases that matter. On AmbiEnt — 1,645 linguist-annotated English examples spanning lexical, syntactic, and pragmatic ambiguity — GPT-4’s generated disambiguations were judged correct only 32 percent of the time by crowdworkers, against 90 percent for the dataset’s own disambiguations [2]. The same model reached 63.0 percent on true/false judgments about whether an interpretation is valid, but when required to answer all four templates correctly for a single disambiguation, performance collapsed to 2.5 percent. That figure is the claim that two readings need not agree, measured directly: the same model, reading the same sentence, does not hold one interpretation consistently. The output is fluent, the meaning is wrong, and nothing flags the error. That is not an acceptable reading mode for a control surface: a system prompt, a tool description, a policy, or a contract.

Binding Versus Hinting

CE does not disambiguate by writing a glossary of definitions into the prose. A definition offered as ordinary sentences is a hint: a human reader may skip it, and a language model may ignore it in favour of context and attention. When a familiar word is replaced by an unfamiliar one and the reading must be inferred from context and stipulation alone, accuracy falls sharply, to near chance for smaller models [3].

Instead, CE records each commitment as JSON-LD frontmatter: a URI bound to each word, shipped with the document. Ordinary reading can still ignore that block. Audit and checking cannot. Downstream processes — noah-linter, conformance checks, archival tools — can be required to consume the URIs rather than re-infer the senses from the prose.

Benefits of using CE

• Less room for error. Every re-derivation is an opportunity to derive something different. In ordinary prose a misread sense produces a confusing sentence. In a control surface it produces an agent that does something other than what it was told, and because the text read fluently, nothing raised an alarm — an alignment failure from ordinary misreading. Removing the inference step removes that class of failure, rather than making it rarer.
• No drift over time. An uncontrolled document grows more ambiguous as it ages, because the reader’s dictionary keeps changing after the writer has stopped. A CE document names each content word by a dereferenceable sense IRI — an Open English WordNet synset page, a Wikidata lexeme for a function word, or a Wiktionary English section for a mark or digit — so a later reader follows the same link the author chose, not a compact prefix whose host no longer exists.
• Native to the semantic web. The metadata is JSON-LD, so a CE document is already RDF: its entities are Wikidata URIs and its sentences are triples that join the wider graph without a mapping layer.
• Durable and citable. Because each assertion carries its own identity and provenance, a CE document decomposes into nanopublications — individually addressable, attributable claims designed for archiving and citation [4]. Long-term storage and documentation are properties of the format, not a separate export step.

Style rules

The style rules are the contract for a CE text: encoding, lexicon, grammar, and typography, together with the specification for citations, punctuation and quotations, words used as words, hyphenation of compound modifiers, dates and times, SI units, and deterministic title case. Every rule exists to remove a judgement call that an ordinary style guide would leave to the writer.

License

This project requires no attribution and may be freely used.

• Language data

  canon/ — CC0 1.0 Universal (Public Domain). Public-domain dedication for the language data itself.

• Code and site

  Everything else (including src/, the site under docs/, and repo tooling) — MIT-0. No attribution required.

Sources

It is ironic that CGEL forms the basis of CE, given Geoffrey K. Pullum’s famous contention that the notion of “a language” is not scientifically reconstructable [8]. Because CE is not intended for the casual register, however, there is perhaps no discrepancy:

It seems to me that the notion of ‘a language’ should not be regarded as scientifically reconstructable at all. … The vagueness is ineliminable, and unproblematic.

1. Stengel-Eskin, E., Rawlins, K., and Van Durme, B. (2024). Zero and few-shot semantic parsing with ambiguous inputs. International Conference on Learning Representations (ICLR). https://arxiv.org/pdf/2306.00824
2. Liu, A., Wu, Z., Michael, J., Suhr, A., West, P., Koller, A., Swayamdipta, S., Smith, N., and Choi, Y. (2023). We’re afraid language models aren’t modeling ambiguity. Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP), 790–807. https://doi.org/10.18653/v1/2023.emnlp-main.51
3. Yae, J. H., Skelly, N. C., Ranly, N. C., and LaCasse, P. M. (2024). Leveraging large language models for word sense disambiguation. Neural Computing and Applications 37, 4093–4110. https://doi.org/10.1007/s00521-024-10747-5
4. Groth, P., Gibson, A., and Velterop, J. (2010). The anatomy of a nanopublication. Information Services and Use 30(1–2), 51–56. https://doi.org/10.3233/ISU-2010-0613
5. Currie, M. B. (2026). Microsoft loves regional date formats but hates “colour” and “honour”. Medium. https://medium.com/@michaelbcurrie/microsoft-loves-your-regional-date-format-but-hates-colour-and-honour-64bcfc7d7ca7
6. Huddleston, R. D., and Pullum, G. K. (2002). The Cambridge Grammar of the English Language. Cambridge University Press. https://en.wikipedia.org/wiki/The_Cambridge_Grammar_of_the_English_Language
7. Reynolds, B., Schneider, N., and Arora, A. (2023). CGELBank Annotation Manual. arXiv. https://arxiv.org/abs/2305.17347
8. Pullum, G. K. (2013). The central question in comparative syntactic metatheory. Mind & Language 28(4), 492–521. https://doi.org/10.1111/mila.12029
9. Krovetz, R. (1998). More than one sense per discourse. Proceedings of the ACL-SIGLEX SENSEVAL Workshop. https://aclanthology.org/S98-1.pdf
10. Star Trek: First Contact (1996). https://en.wikipedia.org/wiki/Star_Trek:_First_Contact. https://perma.cc/3ZRL-GVUR
11. Reynolds, B., Arora, A., and Schneider, N. (2023). Unified syntactic annotation of English in the CGEL framework. Proceedings of the 17th Linguistic Annotation Workshop (LAW-XVII), 220–234. https://people.cs.georgetown.edu/nschneid/p/cgeltrees.pdf
12. Qi, P., Zhang, Y., Zhang, Y., Bolton, J., and Manning, C. D. (2020). Stanza: A Python natural language processing toolkit for many human languages. Association for Computational Linguistics (ACL) System Demonstrations. pdf, bib. https://arxiv.org/abs/2003.07082
13. Geng, S., Josifoski, M., Peyrard, M., and West, R. (2023). Grammar-constrained decoding for structured NLP tasks without finetuning. Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP), 10932–10952. https://doi.org/10.18653/v1/2023.emnlp-main.674
14. Kuhn, T. (2014). A survey and classification of controlled natural languages. Journal of Artificial Intelligence Research 46, 75–122. https://doi.org/10.1613/jair.3908

DATA: Tell me. Are you using a polymer-based neuro-relay to transmit the organic nerve impulses to the central processor in my positronic net? If that is the case, how have you solved the problem of increased signal degradation inherent to organosynthetic transmission across…

BORG QUEEN: Do you always talk this much?

DATA: Not always, but often.

BORG QUEEN: Why do you insist on utilising this primitive linguistic communication? Your android brain is capable of so much more.