mlsynth 0.0.2__tar.gz → 0.0.3__tar.gz

{mlsynth-0.0.2 → mlsynth-0.0.3}/LIMITATIONS.md

@@ -2,25 +2,21 @@
 
 mlsynth never emits a form it has not verified; when it cannot, it raises
 `NotImplementedError` (a supported class, but that case or number is not encoded) or
-`UnsupportedRoot` (the root fits no class). The items below are genuine constraints.
-Planned-but-unbuilt features (gender derivation, clitics, postpositions, stylistic
-variants) are tracked as future work in the README, not here.
-
-## Plurals: partial coverage
-
-- The classes `am_neuter`, `vowel_anuswara`, `i_vowel`, `u_vowel`, and `ṭ_geminate` have
-  plurals. `a_stem` and the chillu classes do not yet: their plurals are
-  animacy-conditioned (`-മാർ` human versus `-കൾ` inanimate, with irregulars like `മക്കൾ`),
-  which is not predictable from the stem shape and is not yet modelled. Requesting one
-  raises `NotImplementedError`.
+`UnsupportedRoot` (the root fits no class). The items below are genuine constraints:
+distinctions the orthography does not carry, and problems outside this package's scope.
+Planned-but-unbuilt features (clitics, postpositions, stylistic variants) are tracked as
+future work in the README, not here.
 
 ## Distinctions the input does not carry
 
+- **Animacy is not recoverable from spelling.** `a_stem` and chillu plurals therefore
+  require an explicit `animacy` and raise without it, since `-മാർ` (human) versus `-കൾ`
+  (inanimate) is not predictable from the stem. For the same reason the accusative
+  defaults to the overt form; the zero-marked inanimate accusative needs
+  `animacy=INANIMATE`.
 - **`u_vowel` and `a_stem` match broadly.** A malformed lemma (a samvruthokaram half-u
   written as a bare `-ു` instead of `-്`, or truncated text) is inflected rather than
   rejected, so callers must pass well-formed lemmas.
-- Without an `animacy` argument the accusative defaults to the overt form; the zero-marked
-  inanimate accusative needs `animacy=INANIMATE`.
 
 ## Out of scope
 

{mlsynth-0.0.2 → mlsynth-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlsynth
-Version: 0.0.2
+Version: 0.0.3
 Summary: Permissive, rule-based Malayalam morphological synthesizer (noun inflection generation).
 Project-URL: Homepage, https://github.com/jayashankarvr/mlsynth
 Project-URL: Source, https://github.com/jayashankarvr/mlsynth
@@ -66,11 +66,13 @@ outside the supported classes raise rather than guess. Five classes (`am_neuter`
 `vowel_anuswara` കലാം, `i_vowel`
 കുട്ടി/സ്ത്രീ, `u_vowel` പശു, `ṭ_geminate` വീട്) are complete in singular and plural;
 `a_stem` (അമ്മ) and the chillu classes (`അവൻ`, `മകൾ`, `കാർ`, `കാൽ`, `തൂൺ`) are
-singular-complete, with plurals pending. Suppletive personal pronouns (ഞാൻ, നീ, അവർ, നാം,
-താൻ, ഇവൻ) are handled through an exception table rather than the rule engine. Includes
-differential object marking and a synthetic/colloquial register for the instrumental. See
-[`LIMITATIONS.md`](LIMITATIONS.md) for the precise gaps. Plurals for `a_stem`/chillu,
-gender derivation, clitics/postpositions, stylistic variants, and verbs are future work.
+singular-complete; their plurals are animacy-conditioned across the full paradigm
+(inanimate `-കൾ`/`-ഉകൾ`, human `-മാർ`/`-ന്മാർ`/`-കാർ`, animate `-കൾ`). Suppletive personal
+pronouns (ഞാൻ, നീ, അവർ, നാം, താൻ, ഇവൻ) are handled through an exception table rather than
+the rule engine. A `derive_feminine` helper builds a feminine lemma from a masculine base
+(എഴുത്തുകാരൻ → എഴുത്തുകാരി) before inflection. Includes differential object marking and a
+synthetic/colloquial register for the instrumental. See [`LIMITATIONS.md`](LIMITATIONS.md)
+for the precise gaps. Clitics/postpositions, stylistic variants, and verbs are future work.
 
 ## Install
 

{mlsynth-0.0.2 → mlsynth-0.0.3}/README.md

@@ -43,11 +43,13 @@ outside the supported classes raise rather than guess. Five classes (`am_neuter`
 `vowel_anuswara` കലാം, `i_vowel`
 കുട്ടി/സ്ത്രീ, `u_vowel` പശു, `ṭ_geminate` വീട്) are complete in singular and plural;
 `a_stem` (അമ്മ) and the chillu classes (`അവൻ`, `മകൾ`, `കാർ`, `കാൽ`, `തൂൺ`) are
-singular-complete, with plurals pending. Suppletive personal pronouns (ഞാൻ, നീ, അവർ, നാം,
-താൻ, ഇവൻ) are handled through an exception table rather than the rule engine. Includes
-differential object marking and a synthetic/colloquial register for the instrumental. See
-[`LIMITATIONS.md`](LIMITATIONS.md) for the precise gaps. Plurals for `a_stem`/chillu,
-gender derivation, clitics/postpositions, stylistic variants, and verbs are future work.
+singular-complete; their plurals are animacy-conditioned across the full paradigm
+(inanimate `-കൾ`/`-ഉകൾ`, human `-മാർ`/`-ന്മാർ`/`-കാർ`, animate `-കൾ`). Suppletive personal
+pronouns (ഞാൻ, നീ, അവർ, നാം, താൻ, ഇവൻ) are handled through an exception table rather than
+the rule engine. A `derive_feminine` helper builds a feminine lemma from a masculine base
+(എഴുത്തുകാരൻ → എഴുത്തുകാരി) before inflection. Includes differential object marking and a
+synthetic/colloquial register for the instrumental. See [`LIMITATIONS.md`](LIMITATIONS.md)
+for the precise gaps. Clitics/postpositions, stylistic variants, and verbs are future work.
 
 ## Install
 

{mlsynth-0.0.2 → mlsynth-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mlsynth"
-version = "0.0.2"
+version = "0.0.3"
 description = "Permissive, rule-based Malayalam morphological synthesizer (noun inflection generation)."
 readme = "README.md"
 requires-python = ">=3.9"

{mlsynth-0.0.2 → mlsynth-0.0.3}/src/mlsynth/__init__.py

@@ -7,11 +7,12 @@ starting with noun inflection. Rules are declarative and provenance-tagged; see
 REFERENCES.md for the linguistic sources and the project's native-ratification
 workflow.
 """
+from .gender import UnsupportedDerivation, derive_feminine
 from .nouns import UnsupportedRoot, list_supported_classes, synthesize_noun
 from .pronouns import is_pronoun, list_pronouns
 from .types import Animacy, Case, Gender, NounFeatures, Number, Register, SynthResult
 
-__version__ = "0.0.2"
+__version__ = "0.0.3"
 __all__ = [
     "Animacy",
     "Case",
@@ -24,6 +25,8 @@ __all__ = [
     "list_supported_classes",
     "is_pronoun",
     "list_pronouns",
+    "derive_feminine",
+    "UnsupportedDerivation",
     "UnsupportedRoot",
     "__version__",
 ]

mlsynth-0.0.3/src/mlsynth/gender.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Gender derivation: build a feminine stem from a masculine one (pre-inflection).
+
+Malayalam marks gender on animate nouns only, and a feminine noun is *derived* from its
+masculine base before any pluralization or case inflection. Two ratified patterns:
+  * a masculine ending in the chillu -ൻ takes -ഇ (എഴുത്തുകാരൻ -> എഴുത്തുകാരി);
+  * a masculine ending in -ഇ takes -ഇനി (വിദ്യാർത്ഥി -> വിദ്യാർത്ഥിനി).
+
+``derive_feminine`` returns a plain root string, ready to feed back into
+``synthesize_noun``. It is deliberately a separate step: derivation is lexical (it builds
+a new lemma), inflection is grammatical. A base that fits neither pattern raises rather
+than guess.
+"""
+from __future__ import annotations
+
+
+class UnsupportedDerivation(ValueError):
+    """The masculine base fits no known feminine-derivation pattern."""
+
+
+def derive_feminine(masculine: str) -> str:
+    """Derive the feminine lemma from a masculine animate base.
+
+    ``-ൻ`` -> ``-ഇ`` (എഴുത്തുകാരൻ -> എഴുത്തുകാരി); ``-ഇ`` -> ``-ഇനി``
+    (വിദ്യാർത്ഥി -> വിദ്യാർത്ഥിനി). The caller is responsible for passing a genuinely
+    animate masculine noun; an unrecognised ending raises :class:`UnsupportedDerivation`.
+    """
+    if masculine.endswith("ൻ"):
+        stem = masculine[:-1]            # drop the chillu; the bare consonant takes -ഇ
+        if stem and "ക" <= stem[-1] <= "ഺ":
+            return stem + "ി"
+    elif masculine.endswith("ി"):
+        return masculine + "നി"          # -ഇ -> -ഇനി
+    raise UnsupportedDerivation(
+        f"cannot derive a feminine form from {masculine!r}; expected a masculine base "
+        f"ending in -ൻ (-> -ഇ) or -ഇ (-> -ഇനി)"
+    )

{mlsynth-0.0.2 → mlsynth-0.0.3}/src/mlsynth/nouns.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 from typing import List, Optional
 
 from .pronouns import PRONOUN_FORMS
-from .rules import CLASSES, NounClass
+from .rules import CLASSES, NounClass, _plural_cases
 from .types import Animacy, Case, Gender, NounFeatures, Number, Register, SynthResult
 
 # Chillu -> base consonant (a chillu reverts before a following vowel sign).
@@ -26,6 +26,41 @@ _CHILLU_BASE = {
     "ൺ": "ണ", "ൻ": "ന", "ർ": "ര", "ൽ": "ല", "ൾ": "ള", "ൿ": "ക",
 }
 
+# Shared oblique plural suffixes for a plural stem ending in a chillu (ൾ for inanimate
+# -കൾ/-ഉകൾ and the irregular മക്കൾ; ർ for the human -മാർ/-ന്മാർ/-കാർ). _attach reverts the
+# chillu before a vowel suffix, so the same paradigm serves every animacy.
+_PLURAL_OBLIQUE = _plural_cases("native-2026", True)
+
+# Suppletive / kinship plurals: root -> plural nominative, checked before the regular
+# animacy rules. These are human/animate, so only the nominative is encoded for now.
+_IRREGULAR_PLURALS = {
+    "മകൾ": "മക്കൾ",     # daughter -> children
+    "മകൻ": "മക്കൾ",     # son -> children
+    "അവൻ": "അവർ",       # he -> they (-അൻ -> -അർ, lexical)
+    "മനുഷ്യൻ": "മനുഷ്യർ",  # man -> people (-അൻ -> -അർ, lexical; not *മനുഷ്യന്മാർ)
+}
+
+
+def _inanimate_plural_stem(cls: NounClass, root: str) -> str:
+    """Inanimate plural: a chillu drops to its *lexical* base consonant via the class
+    oblique + -ഉകൾ (കാർ -> കാറുകൾ, with the retroflex റ, not the dental ര of -മാർ); a
+    bare-consonant (-അ) stem just takes -കൾ (പുഴ -> പുഴകൾ)."""
+    if root and root[-1] in _CHILLU_BASE:
+        return cls.oblique.apply(root) + "ുകൾ"
+    return root + "കൾ"
+
+
+def _human_plural_stem(root: str) -> str:
+    """Human plural (native spec, agentive-aware): the agentive -കാരൻ takes -കാർ
+    (എഴുത്തുകാരൻ -> എഴുത്തുകാർ); any other -ൻ takes -ന്മാർ (അധ്യാപകൻ -> അധ്യാപകന്മാർ);
+    everything else takes -മാർ (അമ്മ -> അമ്മമാർ, ഡോക്ടർ -> ഡോക്ടർമാർ). Lexical -ർ
+    exceptions (മനുഷ്യൻ -> മനുഷ്യർ) belong in the irregular-override table."""
+    if root.endswith("കാരൻ"):
+        return root[:-2] + "ർ"
+    if root.endswith("ൻ"):
+        return root[:-1] + "ന്മാർ"
+    return root + "മാർ"
+
 
 def _is_vowel_sign(ch: str) -> bool:
     o = ord(ch)
@@ -173,6 +208,41 @@ def synthesize_noun(
             stem_class=cls.name, provenance=provenance, verified=verified, analytic=analytic,
         )
 
+    # Animacy-conditioned plurals (a_stem + chillu), computed here rather than table-driven
+    # because the marker depends on animacy. Every plural stem ends in a chillu (ർ for
+    # -മാർ/-ന്മാർ/-കാർ/അവർ/മനുഷ്യർ, ൾ for -കൾ/-ഉകൾ/മക്കൾ), and _attach reverts it before a
+    # vowel suffix (ർ -> ര: അമ്മമാർ + ുടെ -> അമ്മമാരുടെ; ൾ -> ള: മക്കൾ + ുടെ -> മക്കളുടെ), so
+    # one ratified oblique paradigm serves all three animacies. Animacy must be given:
+    # without it -മാർ vs -കൾ is unpredictable, so we raise rather than guess. Non-human
+    # animates pluralize like inanimates (-കൾ) but keep the overt accusative.
+    if number is Number.PLURAL and cls.plural_requires_animacy:
+        if root in _IRREGULAR_PLURALS:
+            plural_nom = _IRREGULAR_PLURALS[root]
+        elif animacy in (Animacy.INANIMATE, Animacy.ANIMATE):
+            plural_nom = _inanimate_plural_stem(cls, root)
+        elif animacy is Animacy.HUMAN:
+            plural_nom = _human_plural_stem(root)
+        else:
+            raise NotImplementedError(
+                f"plural of class {cls.name!r} requires an explicit animacy "
+                f"(HUMAN, ANIMATE, or INANIMATE); got {animacy!r}"
+            )
+        if case is Case.INSTRUMENTAL and register is Register.COLLOQUIAL:
+            return _result(plural_nom + " കൊണ്ട്", [plural_nom, "കൊണ്ട്"],
+                           "native-2026", True, analytic=True)
+        if case is Case.NOMINATIVE:
+            return _result(plural_nom, [plural_nom], "native-2026", True)
+        # DOM zero-marks the inanimate accusative only. Irregulars are human/animate (their
+        # override stem is checked before animacy), so they keep the overt accusative even
+        # if a contradictory animacy=INANIMATE is passed.
+        if (case is Case.ACCUSATIVE and animacy is Animacy.INANIMATE
+                and not marked and root not in _IRREGULAR_PLURALS):
+            return _result(plural_nom, [plural_nom], "native-2026", True)
+        suffix = _PLURAL_OBLIQUE[case].suffix
+        surface = _attach(plural_nom, suffix)
+        morphemes = [plural_nom, suffix] if suffix else [plural_nom]
+        return _result(surface, morphemes, "native-2026", True)
+
     table = cls.plural_cases if number is Number.PLURAL else cls.cases
     try:
         rule = table[case]

{mlsynth-0.0.2 → mlsynth-0.0.3}/src/mlsynth/rules.py

@@ -52,6 +52,9 @@ class NounClass:
     plural_cases: Dict[Case, CaseRule]
     pre: str = ""               # "" | "consonant" | "vowel" (what precedes the ending)
     ends_consonant: bool = False  # match roots ending in a bare consonant (-അ stems)
+    # When True the plural is animacy-conditioned (-മാർ human vs -കൾ inanimate), so it is
+    # computed in nouns.py rather than read from plural_marker/plural_cases (a_stem + chillu).
+    plural_requires_animacy: bool = False
 
 
 _GEMINATE_T = StemTransform("ട്", "ട്ട")  # ട് -> ട്ട for the ṭ_geminate spatial cases
@@ -212,11 +215,13 @@ CLASSES: Dict[str, NounClass] = {
         },
         plural_marker=StemTransform("", ""),
         plural_cases={},
+        plural_requires_animacy=True,
     ),
     # Chillu-final classes. The chillu reverts to its base consonant for vowel suffixes;
     # each chillu takes a different suffix set (native worksheet).
     # ൻ/ൾ take -ഓട് sociative and -ആൽ instrumental (on the reverted stem);
-    # ർ/ൽ/ൺ take the -ഇന- linker (sociative -ഇനോട്, instrumental -ഇനാൽ). Plurals deferred.
+    # ർ/ൽ/ൺ take the -ഇന- linker (sociative -ഇനോട്, instrumental -ഇനാൽ). Plurals are
+    # animacy-conditioned and computed in nouns.py (plural_requires_animacy).
     "chillu_n": NounClass(
         name="chillu_n",
         description="-ൻ final nouns (e.g. അവൻ, നടൻ).",
@@ -237,6 +242,7 @@ CLASSES: Dict[str, NounClass] = {
         },
         plural_marker=StemTransform("", ""),
         plural_cases={},
+        plural_requires_animacy=True,
     ),
     "chillu_ll": NounClass(
         name="chillu_ll",
@@ -258,6 +264,7 @@ CLASSES: Dict[str, NounClass] = {
         },
         plural_marker=StemTransform("", ""),
         plural_cases={},
+        plural_requires_animacy=True,
     ),
     "chillu_r": NounClass(
         name="chillu_r",
@@ -279,6 +286,7 @@ CLASSES: Dict[str, NounClass] = {
         },
         plural_marker=StemTransform("", ""),
         plural_cases={},
+        plural_requires_animacy=True,
     ),
     "chillu_l": NounClass(
         name="chillu_l",
@@ -300,6 +308,7 @@ CLASSES: Dict[str, NounClass] = {
         },
         plural_marker=StemTransform("", ""),
         plural_cases={},
+        plural_requires_animacy=True,
     ),
     "chillu_nn": NounClass(
         name="chillu_nn",
@@ -321,5 +330,6 @@ CLASSES: Dict[str, NounClass] = {
         },
         plural_marker=StemTransform("", ""),
         plural_cases={},
+        plural_requires_animacy=True,
     ),
 }

mlsynth-0.0.3/tests/test_gender.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Feminine derivation (pre-inflection) and its composition with case inflection."""
+import pytest
+
+from mlsynth import (
+    Case,
+    UnsupportedDerivation,
+    derive_feminine,
+    synthesize_noun,
+)
+
+# (masculine base, feminine derivation)
+PAIRS = [
+    ("എഴുത്തുകാരൻ", "എഴുത്തുകാരി"),   # -ൻ -> -ഇ (agentive writer)
+    ("വിദ്യാർത്ഥി", "വിദ്യാർത്ഥിനി"),  # -ഇ -> -ഇനി (student)
+]
+
+
+@pytest.mark.parametrize("masc, fem", PAIRS)
+def test_derive_feminine(masc, fem):
+    assert derive_feminine(masc) == fem
+
+
+def test_derive_then_inflect():
+    # Derivation is pre-inflection: the feminine lemma feeds straight back in and
+    # inflects as an ordinary -ഇ (i_vowel) stem.
+    fem = derive_feminine("എഴുത്തുകാരൻ")          # എഴുത്തുകാരി
+    assert synthesize_noun(fem, Case.GENITIVE).surface == "എഴുത്തുകാരിയുടെ"
+
+
+@pytest.mark.parametrize("bad", ["മരം", "പശു", "വീട്", "അമ്മ", "ൻ"])
+def test_underivable_base_raises(bad):
+    # The last case (a bare chillu) must raise, not emit a lone matra ("ി").
+    with pytest.raises(UnsupportedDerivation):
+        derive_feminine(bad)

{mlsynth-0.0.2 → mlsynth-0.0.3}/tests/test_nouns.py

@@ -181,14 +181,13 @@ def test_explicit_mismatched_class_raises():
         synthesize_noun(AM, Case.ACCUSATIVE, stem_class="i_vowel")
 
 
-def test_a_stem_plural_raises():
+def test_a_stem_chillu_plural_needs_animacy():
+    # a_stem/chillu plurals are animacy-conditioned; without animacy they raise rather
+    # than guess (-മാർ vs -കൾ). Full coverage lives in test_plurals.py.
     with pytest.raises(NotImplementedError):
-        synthesize_noun("അമ്മ", Case.GENITIVE, number=Number.PLURAL)  # a_stem plural not encoded yet
-
-
-def test_unencoded_plural_raises():
+        synthesize_noun("അമ്മ", Case.GENITIVE, number=Number.PLURAL)
     with pytest.raises(NotImplementedError):
-        synthesize_noun("അവൻ", Case.GENITIVE, number=Number.PLURAL)  # chillu has no plural
+        synthesize_noun("കാർ", Case.GENITIVE, number=Number.PLURAL)
 
 
 @pytest.mark.parametrize("root,case,expected", [

mlsynth-0.0.3/tests/test_plurals.py

@@ -0,0 +1,174 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Animacy-conditioned plurals for a_stem + chillu classes (0.0.3).
+
+Inanimate plurals (-കൾ / -ഉകൾ) have the full case paradigm; human plurals
+(-മാർ / -ന്മാർ / -കാർ) and irregulars expose only the nominative; an unknown animacy
+raises rather than guess -മാർ vs -കൾ.
+"""
+import pytest
+
+from mlsynth import Animacy, Case, Number, synthesize_noun
+
+PL = Number.PLURAL
+
+
+def _pl(root, case, **kw):
+    return synthesize_noun(root, case, number=PL, **kw)
+
+
+# --- Inanimate plurals: full paradigm ---------------------------------------
+
+# (root, case, expected) for the inanimate full paradigm.
+INANIMATE_FORMS = [
+    ("പുഴ", Case.NOMINATIVE, "പുഴകൾ"),
+    ("പുഴ", Case.GENITIVE, "പുഴകളുടെ"),
+    ("പുഴ", Case.DATIVE, "പുഴകൾക്ക്"),
+    ("പുഴ", Case.LOCATIVE, "പുഴകളിൽ"),
+    ("പുഴ", Case.SOCIATIVE, "പുഴകളോട്"),
+    # chillu: the lexical base is restored (retroflex റ, not the dental ര of -മാർ).
+    ("കാർ", Case.NOMINATIVE, "കാറുകൾ"),
+    ("കാർ", Case.GENITIVE, "കാറുകളുടെ"),
+    ("കാൽ", Case.NOMINATIVE, "കാലുകൾ"),
+    ("കാൽ", Case.GENITIVE, "കാലുകളുടെ"),
+    ("തൂൺ", Case.NOMINATIVE, "തൂണുകൾ"),
+    ("തൂൺ", Case.GENITIVE, "തൂണുകളുടെ"),
+]
+
+
+@pytest.mark.parametrize("root, case, expected", INANIMATE_FORMS)
+def test_inanimate_plural_paradigm(root, case, expected):
+    r = _pl(root, case, animacy=Animacy.INANIMATE)
+    assert r.surface == expected
+    assert r.verified is True
+    assert r.provenance == "native-2026"
+
+
+def test_inanimate_plural_accusative_is_dom_bare():
+    # DOM: the inanimate accusative defaults to the bare plural nominative.
+    assert _pl("പുഴ", Case.ACCUSATIVE, animacy=Animacy.INANIMATE).surface == "പുഴകൾ"
+    assert _pl("കാർ", Case.ACCUSATIVE, animacy=Animacy.INANIMATE).surface == "കാറുകൾ"
+
+
+def test_inanimate_plural_accusative_marked_is_overt():
+    assert _pl(
+        "പുഴ", Case.ACCUSATIVE, animacy=Animacy.INANIMATE, marked=True
+    ).surface == "പുഴകളെ"
+
+
+# --- Human plurals: nominative only -----------------------------------------
+
+# (root, expected nominative plural) per the agentive-aware rule.
+HUMAN_NOMINATIVES = [
+    ("അമ്മ", "അമ്മമാർ"),            # -അ stem -> -മാർ
+    ("അധ്യാപകൻ", "അധ്യാപകന്മാർ"),  # -ൻ -> -ന്മാർ
+    ("എഴുത്തുകാരൻ", "എഴുത്തുകാർ"),  # agentive -കാരൻ -> -കാർ
+    ("ഡോക്ടർ", "ഡോക്ടർമാർ"),        # -ർ human -> -മാർ
+]
+
+
+@pytest.mark.parametrize("root, expected", HUMAN_NOMINATIVES)
+def test_human_plural_nominative(root, expected):
+    r = _pl(root, Case.NOMINATIVE, animacy=Animacy.HUMAN)
+    assert r.surface == expected
+    assert r.verified is True
+
+
+# The full human-plural oblique paradigm (ർ -> ര before a vowel suffix), native-ratified.
+HUMAN_OBLIQUE = [
+    (Case.ACCUSATIVE, "അമ്മമാരെ"),
+    (Case.GENITIVE, "അമ്മമാരുടെ"),
+    (Case.DATIVE, "അമ്മമാർക്ക്"),     # consonant suffix: chillu stays intact
+    (Case.LOCATIVE, "അമ്മമാരിൽ"),
+    (Case.SOCIATIVE, "അമ്മമാരോട്"),
+    (Case.INSTRUMENTAL, "അമ്മമാരാൽ"),
+    (Case.VOCATIVE, "അമ്മമാരേ"),
+]
+
+
+@pytest.mark.parametrize("case, expected", HUMAN_OBLIQUE)
+def test_human_plural_oblique(case, expected):
+    r = _pl("അമ്മ", case, animacy=Animacy.HUMAN)
+    assert r.surface == expected
+    assert r.verified is True
+
+
+def test_human_plural_accusative_is_overt():
+    # Humans take the overt accusative (DOM zero-marks inanimates only).
+    assert _pl("അമ്മ", Case.ACCUSATIVE, animacy=Animacy.HUMAN).surface == "അമ്മമാരെ"
+
+
+# --- Irregular / suppletive plurals (no animacy needed) ----------------------
+
+IRREGULARS = [
+    ("മകൾ", "മക്കൾ"),
+    ("മകൻ", "മക്കൾ"),
+    ("അവൻ", "അവർ"),
+    ("മനുഷ്യൻ", "മനുഷ്യർ"),  # -അൻ -> -അർ lexical; not the *മനുഷ്യന്മാർ default
+]
+
+
+@pytest.mark.parametrize("root, expected", IRREGULARS)
+def test_irregular_plural(root, expected):
+    r = _pl(root, Case.NOMINATIVE)  # irregulars are unambiguous; no animacy required
+    assert r.surface == expected
+    assert r.verified is True
+
+
+# Irregular oblique cases: ർ-final reverts to ര (അവർ), ൾ-final to ള (മക്കൾ).
+IRREGULAR_OBLIQUE = [
+    ("അവൻ", Case.ACCUSATIVE, "അവരെ"),
+    ("അവൻ", Case.GENITIVE, "അവരുടെ"),
+    ("അവൻ", Case.DATIVE, "അവർക്ക്"),
+    ("മനുഷ്യൻ", Case.ACCUSATIVE, "മനുഷ്യരെ"),
+    ("മനുഷ്യൻ", Case.GENITIVE, "മനുഷ്യരുടെ"),
+    ("മകൾ", Case.GENITIVE, "മക്കളുടെ"),
+    ("മകൾ", Case.DATIVE, "മക്കൾക്ക്"),
+    ("മകൾ", Case.LOCATIVE, "മക്കളിൽ"),
+]
+
+
+@pytest.mark.parametrize("root, case, expected", IRREGULAR_OBLIQUE)
+def test_irregular_plural_oblique(root, case, expected):
+    r = _pl(root, case)
+    assert r.surface == expected
+    assert r.verified is True
+
+
+def test_irregular_accusative_stays_overt_under_contradictory_animacy():
+    # Irregulars are human/animate; a contradictory animacy=INANIMATE must NOT DOM
+    # zero-mark them (അവർ -> overt അവരെ, never the bare അവർ).
+    assert _pl("അവൻ", Case.ACCUSATIVE, animacy=Animacy.INANIMATE).surface == "അവരെ"
+
+
+# --- ANIMATE (non-human) plurals: -കൾ like inanimate, but overt accusative ---
+
+ANIMATE_FORMS = [
+    (Case.NOMINATIVE, "ആനകൾ"),
+    (Case.ACCUSATIVE, "ആനകളെ"),   # overt: DOM zero-marks inanimates only
+    (Case.GENITIVE, "ആനകളുടെ"),
+    (Case.DATIVE, "ആനകൾക്ക്"),
+    (Case.SOCIATIVE, "ആനകളോട്"),
+]
+
+
+@pytest.mark.parametrize("case, expected", ANIMATE_FORMS)
+def test_animate_nonhuman_plural(case, expected):
+    r = _pl("ആന", case, animacy=Animacy.ANIMATE)
+    assert r.surface == expected
+    assert r.verified is True
+
+
+# --- Soundness: animacy is still required -----------------------------------
+
+@pytest.mark.parametrize("root", ["അമ്മ", "കാർ", "അധ്യാപകൻ", "തൂൺ"])
+def test_plural_without_animacy_raises(root):
+    with pytest.raises(NotImplementedError):
+        _pl(root, Case.NOMINATIVE)
+
+
+def test_done_classes_plurals_unaffected():
+    # The five already-complete classes keep their animacy-blind plurals.
+    assert synthesize_noun("മരം", Case.NOMINATIVE, number=PL).surface == "മരങ്ങൾ"
+    assert synthesize_noun("കുട്ടി", Case.NOMINATIVE, number=PL).surface == "കുട്ടികൾ"
+    assert synthesize_noun("വീട്", Case.GENITIVE, number=PL).surface == "വീടുകളുടെ"