Pluralization Rules in Welsh and Why They Break Standard Libraries

Welsh needs as many plural message forms as Arabic does, and for completely different reasons. Two of its six categories are single numbers — 3 and 6 — which looks arbitrary until you know what those two numerals do to the word after them.

Six categories, and where they come from

The Unicode Consortium’s CLDR data assigns Welsh the full set of six cardinal categories, one of only a small number of languages that uses all of them. As published in CLDR’s language plural rules chart, the rules are unusually simple to read:

zero   n = 0
one    n = 1
two    n = 2
few    n = 3
many   n = 6
other  everything else

No modular arithmetic, no exception ranges — just five specific numbers and a default. Compare Polish, where the rules are entirely modular and no single number gets its own category except 1. The two languages need the same machinery for opposite reasons.

The reason 3 and 6 are singled out is the initial consonant mutation system. Welsh numerals change the first consonant of the following word, and they do not all change it the same way. Tri (three, masculine) and chwe (six) both trigger the aspirate mutation, turning initial c, p and t into ch, ph and th:

ci      "dog"       →  un ci        (1)
                       dau gi       (2, soft mutation after dau)
                       tri chi      (3, aspirate mutation after tri)
                       pedwar ci    (4, no mutation)
                       pum ci       (5, no mutation)
                       chwe chi     (6, aspirate mutation after chwe)
                       saith ci     (7, no mutation)

So the string that follows the number is genuinely different at 3 and at 6, and identical at 4, 5, 7 and everything above. A category system that exists to answer “does this count need a different string?” must therefore split out exactly 3 and exactly 6, and nothing else. The categories are not a statement about Welsh number semantics; they are the minimal partition that captures where the surface form changes. That is the general principle behind CLDR and Welsh is its clearest illustration.

Dau (two) triggers the softer and more common soft mutation instead — ci becomes gi — which is why 2 also gets its own category. And 2, 3 and 4 have separate masculine and feminine forms (dau/dwy, tri/tair, pedwar/pedair), a distinction that lives outside the plural-category system entirely and has to be handled by having separate strings per noun.

The noun after a numeral is singular

The second assumption Welsh breaks is the one nobody writes down: that a count greater than one takes a plural noun.

In Welsh it does not. The standard construction is numeral plus singular noun: pum ci is “five dog”, deg mlynedd is “ten year”, tri llyfr is “three book”. The plural form cŵn exists and is used when there is no numeral — y cŵn, “the dogs” — but a counted quantity does not take it. The alternative construction with o (“of”) does take the plural, pump o gŵn, and is the more literary option.

The practical consequence is that a pipeline which asks a model for “the plural of this Welsh noun” and then interpolates it after a number produces text that is wrong at every count. What you need is the singular for the counted construction and the plural for the uncounted one, which is not the shape most localisation tooling offers.

Plural formation runs both directions

Welsh plural morphology has no single productive suffix. It has several, plus internal vowel change, plus a class of nouns where the derivation runs the other way.

• Suffixation — -au, -iau, -on, -ion, -i, -ydd, -oedd: llyfr → llyfrau, afal → afalau, mynydd → mynyddoedd.
• Vowel change, with no suffix at all — bachgen → bechgyn, castell → cestyll, tŷ → tai, brawd → brodyr. A rule of the form “stem plus ending” cannot express these.
• Singulatives, where the collective is the base form and the singular is derived by adding -yn or -en: plant (children) → plentyn (a child), coed (trees, wood) → coeden (a tree), adar (birds) → aderyn (a bird), moch (pigs) → mochyn (a pig). Any code or prompt that assumes the singular is the shorter, more basic form has these exactly backwards.

What a generic library gets wrong

Three distinct failures, in increasing order of how hard they are to notice.

• A hand-written plural table with two branches. Any framework that ships its own plural logic rather than reading CLDR tends to give a language one or two forms, and for Welsh that is wrong at 0, 2, 3 and 6. This is the loud failure and it shows up the first time a Welsh speaker reads the interface.
• Welsh mapped onto English rules by fallback. If a library has no entry for cy it may fall back to a default one/other rule rather than erroring, so the code path looks healthy and the output is quietly two-category.
• A correct six-branch message filled with wrong strings. The category selection is right, but whoever filled the branches put the plural noun in all of them, or forgot the mutation, so tri ci appears where tri chi belongs. No tool catches this; the plural-rules library’s job ended at picking a branch.

Use a CLDR-backed implementation and check what it returns before filling the branches:

const pr = new Intl.PluralRules("cy");
[0, 1, 2, 3, 4, 5, 6, 7, 42].map((n) => [n, pr.select(n)]);
// [[0,"zero"],[1,"one"],[2,"two"],[3,"few"],[4,"other"],
//  [5,"other"],[6,"many"],[7,"other"],[42,"other"]]

What this means for generated Welsh

Welsh is a comparatively low-resource language for large models, and the failure modes stack: mutation is a system that operates on the first letter of a word based on what precedes it, which is exactly the kind of long-thin dependency that thins out when a language is a small share of training data.

Two things follow for anyone generating Welsh. First, ask for forms rather than sentences: request the singular, the plural, and the mutated form after dau, tri and chwe as separate labelled items, and assemble them yourself against Intl.PluralRules. A model asked to fill six branches at once will produce six plausible strings and get the mutations right in some of them. Second, treat the output as a draft for a Welsh speaker rather than as a deliverable — the Welsh Language Commissioner’s standards apply to a good deal of published Welsh in Wales, and unmutated machine output is immediately visible to any reader.

The comparison worth making is with Polish, whose four categories are defined by modular arithmetic, and the wider picture of how many forms different languages need is in how many plural forms a language actually needs.