Nomina im Glossarium

Inhaltsverzeichnis

1. Überblick
2. Datenbankfelder
3. Erforderliche Felder
4. Deklinationsklassen
5. Genera
6. Numerus-Besonderheiten
7. Dritte Deklination
8. Sonderformen und Anomalia
9. Morphologie-Struktur
10. Morphologie-Generierung
11. Methoden
12. Verwendungsbeispiele
13. Beispieldaten

---

Überblick

Nomina (Substantive) bilden eine der zentralen Wortarten im Glossarium-System von Hermeneus. Sie werden in der Tabelle glossarium_nomina gespeichert und durch die Model-Klasse App\Models\Nomen repräsentiert.

Grundlegende Eigenschaften

• Model-Klasse: App\Models\Nomen
• Morpher-Klasse: App\Morpher\NomenMorpher
• MorphInfo-Handler: App\Morpher\NomenMorphInfoHandler
• Tabelle: glossarium_nomina
• Route: nomina
• Morphologisierbar: Ja (automatisch und manuell)

Linguistische Merkmale

Nomina werden im Lateinischen charakterisiert durch:

• Deklination: Zugehörigkeit zu einer von fünf Deklinationsklassen plus indeklinablen Formen
• Genus: Grammatisches Geschlecht (maskulin, feminin, neutrum)
• Numerus: Singular und Plural (mit Sonderformen)
• Kasus: Sechs Fälle (Nominativ, Genitiv, Dativ, Akkusativ, Vokativ, Ablativ)

---

Datenbankfelder

Basisfelder

Feld	Typ	Beschreibung
id	INT	Primärschlüssel (AUTO_INCREMENT)
lemma	VARCHAR	Grundform (Nominativ Singular)
info	VARCHAR	Zusätzliche Informationen (optional)
bedeutung	VARCHAR	Deutsche Hauptbedeutung
bedeutungen_alle	TEXT	Weitere/alternative Bedeutungen
morph	JSON	Morphologische Daten als JSON
morph_mode	INT	Morphologisierungsmodus (0=auto, 1=manuell)
status	INT	Morphologisierungsstatus (0=offen, 1=in Arbeit, 2=fertig)
created_at	TIMESTAMP	Erstellungszeitpunkt
updated_at	TIMESTAMP	Letzte Aktualisierung
deleted_at	TIMESTAMP	Soft-Delete (NULL wenn nicht gelöscht)
created_by_id	INT	Benutzer-ID des Erstellers
updated_by_id	INT	Benutzer-ID des letzten Bearbeiters

Nomenspezifische Felder (Formenbildung)

Feld	Typ	Werte	Beschreibung
fb_stamm	VARCHAR	-	Deklinationsstamm des Nomens
fb_dklasse	ENUM	'a', 'o', 'u', 'e', '3dekl', 'indekl'	Deklinationsklasse
fb_genus	ENUM	'm', 'f', 'n', 'mf'	Grammatisches Geschlecht
fb_bes_numerus	ENUM	'', 'sgtantum', 'pltantum'	Numerus-Besonderheiten

---

Erforderliche Felder

Für die automatische Morphologisierung eines Nomens sind folgende Felder zwingend erforderlich:

$RequiredFields = [
    'lemma',
    'fb_stamm',
    'fb_dklasse',
    'fb_genus',
    'bedeutung'
];

Erläuterung:

• lemma: Das Grundwort im Nominativ Singular (z.B. "amica", "dominus", "corpus")
• fb_stamm: Der Stamm, an den die Kasusendungen angehängt werden (z.B. "amic", "domin", "corpor")
• fb_dklasse: Die Deklinationsklasse bestimmt die Endungen
• fb_genus: Das Genus beeinflusst bei der o-Deklination und 3. Deklination die Endungen
• bedeutung: Semantische Information (für Glossar erforderlich)

Validierung

Die Methode IsValid() prüft, ob alle erforderlichen Felder ausgefüllt sind:

public function IsValid(): bool
{
    if (
        ! empty($this->lemma) &&
        ! empty($this->fb_stamm) &&
        ! empty($this->fb_genus) &&
        ! empty($this->fb_dklasse)
    ) {
        return true;
    }

    return false;
}

---

Typische Fehler und Hinweise zum Ausfüllen

Bei der Erfassung von Nomina im Glossarium treten häufig wiederkehrende Fehler auf, die die automatische Morphologie-Generierung beeinträchtigen oder zu falschen Formen führen. Diese Übersicht hilft, häufige Fallstricke zu vermeiden.

Einleitung

Die korrekte Erfassung der Formenbildungsfelder (fb_*) ist entscheidend für die automatische Morphologisierung. Fehlerhafte Einträge führen zu:

• Falschen oder fehlenden Deklinationsformen
• Fehlgeschlagener Morphologie-Generierung
• Doppelten Einträgen im System
• Inkonsistenten Suchergebnissen

Die folgende Tabelle zeigt typische Fehler, ihre Auswirkungen und die korrekte Vorgehensweise.

Fehlerübersicht

Feld	Typischer Fehler	Auswirkung	Richtig	Hinweis
lemma	Großschreibung bei Appellativa: Amicus statt amicus	Falsche Sortierung, Suchergebnisse unvollständig	amicus	Nur Eigennamen werden großgeschrieben. Appellativa (gewöhnliche Substantive) immer kleinschreiben.
lemma	Eigenname als Nomen erfasst: Thessalus als Nomen statt als Eigenname	Falsche Kategorisierung, doppelte Einträge möglich	Separate Tabelle glossarium_eigennamen	Personennamen, Ortsnamen und Götternamen gehören in die Eigennamen-Tabelle. Bei Bedarf convertEigenname() verwenden.
lemma	Genitiv statt Nominativ: amici statt amicus	Alle generierten Formen sind falsch, Lemma nicht auffindbar	amicus	Das Lemma ist immer der Nominativ Singular (bzw. Plural bei Pluralia tantum). Genitiv wird automatisch generiert.
lemma	Plural statt Singular: amici bei normalem Nomen	Falsche Grundform, fehlerhafte Deklination	amicus	Bei gewöhnlichen Nomina immer Singular als Lemma. Nur bei echten Pluralia tantum den Plural verwenden.
lemma	Adjektiv als Nomen: bonus statt in Adjektiv-Tabelle	Falsche Wortart, fehlende Adjektivformen	Tabelle glossarium_adjektiva	Adjektive gehören in die Adjektiv-Tabelle, außer bei echter Substantivierung (z.B. captivus = der Gefangene).
fb_stamm	Stamm mit Kasusendung: amic-us statt amic	Doppelte Endungen (amicusus, amicusi), alle Formen falsch	amic	Der Stamm ist die Form OHNE Nominativ-Endung. Bei amicus ist der Stamm amic, bei amica ebenfalls amic.
fb_stamm	Nominativ statt Stamm bei 3. Dekl.: consul statt consul (hier gleich, aber bei homo: homo statt homin)	Falsche Formen ab Genitiv: homois statt hominis	Bei homo: homin Bei consul: consul	Bei 3. Deklination: Genitiv-Form nehmen und -is entfernen. Beispiel: homo, hominis → Stamm = homin.
fb_stamm	Falscher Stamm bei 3. Dekl.: homo statt homin	Alle Formen außer Nominativ sind falsch	homin	Regel: Gen. Sg. minus -is = Stamm. Test: homin + is = hominis (korrekt).
fb_dklasse	Falsche Deklinationsklasse: o statt a bei amica	Komplett falsche Endungen: amici, amico, amicum statt amicae, amicae, amicam	a	Prüfen: a-Dekl. (meist -a), o-Dekl. (-us/-er/-um), u-Dekl. (-us mit Gen. -ūs), e-Dekl. (-es), 3dekl (variabel), indekl (keine Flexion).
fb_dklasse	3dekl statt indekl: Bei fas, nefas	Falsche Formen generiert, obwohl keine Flexion existiert	indekl	Indeklinabilia haben keine Kasusformen. Typisch: fas, nefas. Nicht mit 3. Deklination verwechseln.
fb_genus	Falsches Genus: m statt f bei amica	Falsche Bedeutungszuordnung, bei Neutra falsche Endungen	f	Genus aus Wörterbuch prüfen. Bei a-Dekl. meist f, bei o-Dekl. -us/-er meist m, -um immer n.
fb_genus	Genus bei Plurale tantum falsch: m bei arma (sollte n sein)	Falsche Formen, falscher Lemma-Info	n (bei arma)	Genus muss auch bei Pluralia tantum korrekt sein, da es die Endungen beeinflusst (z.B. arma, armorum n.).
fb_bes_numerus	pltantum bei Wort mit Singular-Bedeutung: amicus mit pltantum	Alle Singular-Formen werden gelöscht, obwohl sie existieren	`` (leer lassen)	Nur bei echten Pluralia tantum verwenden. Test: Gibt es eine sinnvolle Singular-Form? Dann NICHT pltantum.
fb_bes_numerus	Fehlt bei echtem Plurale tantum: arma ohne pltantum	Falsche Singular-Formen werden generiert, die nicht existieren	pltantum	Echte Pluralia tantum: arma, castra, liberi, parentes, opes, fruges, preces.
Allgemein	Doppelter Eintrag desselben Nomens: dominus zweimal mit verschiedenem Genus (m und f)	Redundanz, Verwirrung, Suchergebnisse zeigen beide	Einen Eintrag mit korrektem Genus, anderen löschen	Vor Neuanlage: Suche nach bestehendem Eintrag. Bei mehrdeutigem Genus (selten): mf verwenden.
Allgemein	Doppelter Eintrag mit verschiedenen Bedeutungen: sodalis = "Gefährte" UND "Mitglied"	Redundanz, beide Einträge haben identische Morphologie	Einen Eintrag mit Hauptbedeutung in bedeutung, weitere in bedeutungen_alle	Mehrere Bedeutungen desselben Wortes gehören in EIN Lemma (Feld bedeutungen_alle).
Allgemein	Nomen UND Eigenname doppelt: Iulius als Nomen UND Eigenname	Redundanz, doppelte Suchergebnisse	Bei Personennamen: nur Eigenname Bei Appellativ: nur Nomen	Iulius (Personenname) → Eigennamen-Tabelle. Iulius als Adjektiv ("julisch") → Adjektiv-Tabelle.
bedeutung	Artikel inkonsistent: "der Freund" vs. "Freund"	Inkonsistente Darstellung im Glossar	Immer MIT Artikel: "der Freund", "die Freundin", "das Haus"	Deutsche Bedeutung IMMER mit bestimmtem Artikel angeben, da dieser das Genus anzeigt.

Checkliste vor dem Speichern

Bevor ein Nomen gespeichert wird, sollten folgende Punkte geprüft werden:

1. Lemma-Prüfung:

   • Ist das Lemma ein Nominativ Singular (oder Plural bei Plurale tantum)?
   • Ist die Groß-/Kleinschreibung korrekt (Appellativ vs. Eigenname)?
   • Existiert das Lemma bereits im System?

2. Stamm-Prüfung:

   • Ist der Stamm OHNE Nominativ-Endung angegeben?
   • Bei 3. Deklination: Stamm = Genitiv minus -is?

3. Deklinationsklasse-Prüfung:

   • Passt die Deklinationsklasse zur Lemma-Endung?
   • Ist indekl bei wirklich indeklinablen Wörtern gewählt?

4. Genus-Prüfung:

   • Ist das Genus aus zuverlässiger Quelle (Wörterbuch)?
   • Passt das Genus zur typischen Genus-Verteilung der Deklinationsklasse?

5. Numerus-Prüfung:

   • Ist pltantum nur bei echten Pluralia tantum gesetzt?
   • Ist sgtantum nur bei echten Singularia tantum gesetzt?

6. Bedeutungs-Prüfung:

   • Ist die Bedeutung mit Artikel angegeben?
   • Sind mehrere Bedeutungen in bedeutungen_alle eingetragen?

7. Wortart-Prüfung:

   • Ist das Wort wirklich ein Nomen (nicht Adjektiv, Eigenname, etc.)?

8. Validierungs-Test:

   if ($nomen->IsValid()) {
       $nomen->morph();  // Erfolg
   } else {
       // Pflichtfelder fehlen
   }

Korrektur fehlerhafter Einträge

Bei Entdeckung fehlerhafter Einträge:

1. Korrektur der Formenbildungsfelder: Eintrag bearbeiten, Felder korrigieren
2. Neu morphologisieren: $nomen->morph() aufrufen, um korrekte Formen zu generieren
3. Status prüfen: status sollte auf 2 (fertig morphologisiert) stehen
4. Test: Stichprobenartige Prüfung einiger generierter Formen im morph JSON

Bei strukturell falschen Einträgen (z.B. Eigenname statt Nomen):

$nomen->convertEigenname();  // Verschiebt in Eigennamen-Tabelle

---

Deklinationsklassen

Übersicht

Klasse	Code	Beschreibung	Beispiele
a-Deklination	a	Primär feminina, einige maskulina	amica, domina, poeta, nauta
o-Deklination	o	Maskulina auf -us/-er, neutra auf -um	amicus, puer, templum
u-Deklination	u	Maskulina auf -us, neutra auf -u	exercitus, cornu
e-Deklination	e	Primär feminina	res, spes, dies
3. Deklination	3dekl	Konsonantisch und vokalisch	homo, corpus, mare, civis
Indeklinabel	indekl	Keine Flexion	fas, nefas

a-Deklination

Charakteristika:

• Primär feminina (amica, domina)
• Einige maskulina (poeta, nauta, agricola)
• Genitiv Singular auf -ae
• Nominativ Plural auf -ae

Standardendungen:

Kasus	Singular	Plural
Nom.	-a	-ae
Gen.	-ae	-arum
Dat.	-ae	-is
Akk.	-am	-as
Vok.	-a	-ae
Abl.	-a	-is

Sonderformen:

• familia: Genitiv/Dativ Singular auch familias
• dea, filia: Dativ/Ablativ Plural deabus, filiabus (zur Unterscheidung von deis, filiis)

o-Deklination

Charakteristika:

• Maskulina auf -us oder -er (amicus, puer, ager)
• Neutra auf -um (templum, bellum)
• Genitiv Singular auf -i

Maskulina auf -us:

Kasus	Singular	Plural
Nom.	-us	-i
Gen.	-i	-orum
Dat.	-o	-is
Akk.	-um	-os
Vok.	-e	-i
Abl.	-o	-is

Besonderheit: Nomina auf -ius haben den Vokativ auf -i (nicht -ie):

• filius → Vok. Sg. fili (nicht filie)

Maskulina auf -er:

• Vokativ Singular = Nominativ Singular
• Beispiele: puer (Vok. puer), magister (Vok. magister)

Neutra auf -um:

Kasus	Singular	Plural
Nom.	-um	-a
Gen.	-i	-orum
Dat.	-o	-is
Akk.	-um	-a
Vok.	-um	-a
Abl.	-o	-is

Neutrum-Regel: Nominativ, Akkusativ und Vokativ sind in jedem Numerus gleich.

Sonderformen:

• Neutra auf -us: vulgus, virus (selten)

u-Deklination

Charakteristika:

• Primär maskulina (exercitus, senatus)
• Wenige neutra (cornu, genu)
• Genitiv Singular auf -us (lang: -ūs)

Maskulina:

Kasus	Singular	Plural
Nom.	-us	-us
Gen.	-us (-ūs)	-uum
Dat.	-ui	-ibus
Akk.	-um	-us
Vok.	-us	-us
Abl.	-u	-ibus

Neutra:

Kasus	Singular	Plural
Nom.	-u	-ua
Gen.	-us (-ūs)	-uum
Dat.	-u	-ibus
Akk.	-u	-ua
Vok.	-u	-ua
Abl.	-u	-ibus

Sonderformen:

• domus: Mischt u- und o-Deklinationsformen
• exercitus, lacus, arcus, artus, tribus: Verschiedene Sonderendungen

e-Deklination

Charakteristika:

• Primär feminina (res, spes, fides)
• Wenige maskulina (dies, meridies)
• Genitiv Singular auf -ei

Standardendungen:

Kasus	Singular	Plural
Nom.	-es	-es
Gen.	-ei	-erum
Dat.	-ei	-ebus
Akk.	-em	-es
Vok.	-es	-es
Abl.	-e	-ebus

Indeklinabel

Charakteristika:

• Keine Flexion
• Form bleibt in allen Kasus und Numeri gleich
• Meist neutra

Beispiele:

• fas (das göttliche Recht)
• nefas (das Frevel)

---

Genera

Übersicht

Genus	Code	Beschreibung
Maskulinum	m	Männliches Geschlecht
Femininum	f	Weibliches Geschlecht
Neutrum	n	Sächliches Geschlecht
Maskulinum/Femininum	mf	Beide Genera möglich (selten)

Genus-Tendenzen nach Deklinationsklasse

a-Deklination:

• Primär feminina: amica, domina, puella
• Maskulina: Personenbezeichnungen wie poeta, nauta, agricola

o-Deklination:

• Maskulina: -us, -er Endungen
• Neutra: -um Endungen

u-Deklination:

• Primär maskulina: exercitus, senatus
• Neutra: cornu, genu

e-Deklination:

• Primär feminina: res, spes, fides
• Maskulina: dies (m/f), meridies

3. Deklination:

• Alle drei Genera möglich
• Genus muss individuell angegeben werden

Bedeutung des Genus für die Morphologie

Das Genus beeinflusst:

1. Bei o-Deklination: Unterscheidung zwischen maskulinen/femininen (-us/-er) und neutralen (-um) Formen
2. Bei 3. Deklination: Neutrum-Regel (Nom. = Akk. = Vok. in jedem Numerus; Plural auf -a)
3. Bei u-Deklination: Unterscheidung zwischen maskulinen und neutralen Formen

---

Numerus-Besonderheiten

Plurale tantum

Definition: Nomina, die nur im Plural vorkommen.

Feld-Wert: fb_bes_numerus = 'pltantum'

Auswirkung: Alle Singular-Formen werden im JSON leer gelassen.

Beispiele:

• arma, armorum n. - die Waffen
• castra, castrorum n. - das Lager
• liberi, liberorum m. - die Kinder
• parentes, parentum m. - die Eltern
• opes, opum f. - die Macht, die Mittel
• fruges, frugum f. - die Feldfrüchte
• preces, precum f. - die Bitten

Morphologie-Besonderheit: Genitiv-Endung bei Pluralia tantum:

• a-Deklination: -arum statt -ae im getLemmaInfo()
• o-Deklination: -orum statt -i
• u-Deklination: -uum statt -ūs

Singulare tantum

Definition: Nomina, die nur im Singular vorkommen.

Feld-Wert: fb_bes_numerus = 'sgtantum'

Auswirkung: Alle Plural-Formen werden im JSON leer gelassen.

Beispiele:

• Iuppiter, Iovis m. - Jupiter
• supellex, supellectilis f. - Hausrat (Singular tantum, Anomale)

Implementierung im NomenMorpher

if ($this->IsPluraleTantum()) {
    $this->clearSingular();
}
if ($this->IsSingulareTantum()) {
    $this->clearPlural();
}

Die Methoden clearSingular() und clearPlural() setzen alle Formen des jeweiligen Numerus auf leere Strings.

---

Dritte Deklination

Die dritte Deklination ist die umfangreichste und variabelste Deklinationsklasse im Lateinischen. Das System unterscheidet zwischen konsonantischer und vokalischer Deklination.

Konsonantische vs. vokalische Deklination

Konsonantische Deklination (Regelfall):

• Genitiv Plural auf -um
• Ablativ Singular auf -e
• Nominativ/Akkusativ Plural Neutrum auf -a

Vokalische Deklination:

• Genitiv Plural auf -ium
• Ablativ Singular auf -i (Gruppe 2)
• Akkusativ Singular auf -im (Gruppe 2)
• Akkusativ Plural auf -is (Gruppe 2)
• Nominativ/Akkusativ Plural Neutrum auf -ia (Gruppe 1)

Regelfall: Konsonantische Deklination

Standardendungen:

$this->kasusendungen = array(
    'sg_gen' => 'is',
    'sg_dat' => 'i',
    'sg_akk' => 'em',
    'sg_abl' => 'e',
    'pl_nom' => 'es',
    'pl_gen' => 'um',
    'pl_dat' => 'ibus',
    'pl_akk' => 'es',
    'pl_vok' => 'es',
    'pl_abl' => 'ibus'
);

Beispiel: homo, hominis m. (der Mensch)

Kasus	Singular	Plural
Nom.	homo	homines
Gen.	hominis	hominum
Dat.	homini	hominibus
Akk.	hominem	homines
Vok.	homo	homines
Abl.	homine	hominibus

Vokalische Deklination: Gruppe 1 (RH §38, 1)

Neutra auf -al, -ar, -e:

Erkennungsregel im Code:

public function IsIn3DeklNeutraVokalischGruppe1()
{
    if ($this->lemma === 'moenia') {
        return true;
    }
    if (($this->endung == 'al' && $this->IsNeutrum()) ||
        ($this->endung == 'ar' && $this->IsNeutrum()) ||
        ($this->lastletter == 'e' && $this->IsNeutrum())) {
        return true;
    }

    return false;
}

Charakteristika:

• Nom./Akk./Vok. Plural auf -ia (statt -a)
• Genitiv Plural auf -ium (statt -um)
• Ablativ Singular auf -i (statt -e)
• Akkusativ Singular = Nominativ Singular (Neutrum-Regel)

Beispiele:

• animal, animalis n. - das Tier, Lebewesen
• exemplar, exemplaris n. - das Beispiel, Muster
• mare, maris n. - das Meer
• moenia, moenium n. - die Stadtmauern (Plurale tantum)

Endungen Gruppe 1:

$this->kasusendungen['pl_nom'] = 'ia';
$this->kasusendungen['pl_akk'] = 'ia';
$this->kasusendungen['pl_vok'] = 'ia';
$this->kasusendungen['pl_gen'] = 'ium';

// Singular (wenn kein Plurale tantum)
$this->Substitutes['1_sg']['4_akk'] = $this->lemma;
$this->kasusendungen['sg_abl'] = 'i';

Vokalische Deklination: Gruppe 2 (RH §38, 2)

Bestimmte Wörter mit vokalischen Endungen:

Hardcodierte Liste im Code:

public $dritte_dekl_vokalisch_gruppe2 = array(
    'turris', 'febris', 'puppis', 'securis',
    'puppis', 'sitis', 'Tiberis', 'Neapolis'
);

Charakteristika:

• Genitiv Plural auf -ium (statt -um)
• Akkusativ Singular auf -im (statt -em)
• Akkusativ Plural auf -is (statt -es)
• Ablativ Singular auf -i (statt -e)

Beispiele:

• turris, turris f. - der Turm
• febris, febris f. - das Fieber
• puppis, puppis f. - das Heck (eines Schiffes)
• securis, securis f. - die Axt

Endungen Gruppe 2:

$this->kasusendungen['pl_gen'] = 'ium';
$this->kasusendungen['pl_akk'] = 'is';
$this->kasusendungen['sg_akk'] = 'im';
$this->kasusendungen['sg_abl'] = 'i';

Genitiv auf -ium (RH §40)

Bestimmte Wörter haben den Genitiv Plural auf -ium, aber sonst konsonantische Endungen:

Hardcodierte Liste im Code:

public $dritte_dekl_genitiv_ium = array(
    'ovis', 'hostis', 'civis', 'navis', 'avis',
    'nubes', 'mons', 'pons', 'mors', 'piscis',
    'mortalis', 'orbis', 'urbs', 'axis', 'vulpes',
    'pars', 'parens', 'os', 'imber', 'venter',
    'faux', 'lis', 'nix', 'optimates', 'penates',
    'Samnites', 'testis', 'ignis'
);

Erkennungsregeln (RH §40, 1a): Gleichsilbige Substantive auf -is/-es:

public function HasGenitivAufIum()
{
    // Hardcodierte Liste
    if (in_array($this->lemma, $this->dritte_dekl_genitiv_ium)) {
        return true;
    }

    // Gleichsilbige auf -is oder -es
    if (substr($this->lemma, -2) === 'is' || substr($this->lemma, -2) === 'es') {
        // Ausnahmen
        if (in_array($this->lemma, ['canis', 'iuvenis', 'sedes'])) {
            return false;
        }

        // Silbenzahl vergleichen: Nom. Sg. = Gen. Sg.
        $syllable = new Syllable('en-us');
        if ($syllable->countSyllablesText($this->lemma) ===
            $syllable->countSyllablesText($this->stamm . 'is')) {
            return true;
        }
    }

    return false;
}

Beispiele:

• civis, civis m. - der Bürger (Nom. 2 Silben, Gen. civis 2 Silben → gleichsilbig → Gen. Pl. civium)
• navis, navis f. - das Schiff (Gen. Pl. navium)
• mons, montis m. - der Berg (Gen. Pl. montium)
• urbs, urbis f. - die Stadt (Gen. Pl. urbium)

Ausnahmen (Gen. Pl. auf -um trotz Gleichsilbigkeit):

• canis, canis m. - der Hund (Gen. Pl. canum)
• iuvenis, iuvenis m. - der Jüngling (Gen. Pl. iuvenum)
• sedes, sedis f. - der Sitz (Gen. Pl. sedum)

Neutra der 3. Deklination

Neutrum-Regel: Nominativ = Akkusativ = Vokativ in jedem Numerus.

Erkennungsmethode:

public function IsNeutrum()
{
    if ($this->Nomen->fb_genus == 'n') {
        return true;
    }

    return false;
}

Standardendungen für Neutra:

private function defineNeutrumEndungen()
{
    $this->Substitutes['1_sg']['4_akk'] = $this->lemma;  // Akk. = Nom.
    $this->kasusendungen['pl_nom'] = 'a';
    $this->kasusendungen['pl_akk'] = 'a';
    $this->kasusendungen['pl_vok'] = 'a';
}

Beispiel: corpus, corporis n. (der Körper)

Kasus	Singular	Plural
Nom.	corpus	corpora
Gen.	corporis	corporum
Dat.	corpori	corporibus
Akk.	corpus	corpora
Vok.	corpus	corpora
Abl.	corpore	corporibus

---

Sonderformen und Anomalia

Sonderformen

Der NomenMorpher definiert eine Liste von Nomina, die Sonderformen aufweisen:

public $sonderformen = array(
    'familia', 'deus', 'dea', 'filia', 'filius',
    'negotium', 'nummus', 'modius', 'sestertius',
    'talentum', 'duumvir', 'triumvir', 'decemvir',
    'faber', 'liberi', 'locus', 'arcus', 'artus',
    'tribus', 'exercitus', 'lacus', 'domus',
    'parentes', 'mensis', 'vates', 'mus', 'fraus',
    'civitas', 'Iuppiter', 'senex', 'bos', 'supellex',
    'caro', 'nix', 'iter', 'vas', 'vis', 'opes',
    'fruges', 'preces', 'fas', 'nefas'
);

Für diese Lemmata werden spezielle Substitutionen vorgenommen oder sie müssen manuell morphologisiert werden (morph_mode = 1).

Anomale Nomina

Definition: Nomina mit unregelmäßigen Formen, die nicht den Standardregeln folgen.

public $anomalia = [
    'Iuppiter', 'senex', 'bos', 'suppellex',
    'caro', 'nix', 'iter', 'vas'
];

Iuppiter (Jupiter)

Besonderheit: Singulare tantum, stark anomale Formen.

Stamm wechselt: Iuppiter → Gen. Iovis

Implementierung:

case 'Iuppiter':
    $this->clearPlural();  // Nur Singular
    break;

Vollständige Deklination:

Kasus	Singular
Nom.	Iuppiter
Gen.	Iovis
Dat.	Iovi
Akk.	Iovem
Vok.	Iuppiter
Abl.	Iove

bos (Rind)

Besonderheiten: Genitiv Plural boum, Dativ/Ablativ Plural bubus/bobus.

Implementierung:

case 'bos':
    $this->Substitutes['2_pl']['2_gen'] = 'boum';
    $this->Substitutes['2_pl']['3_dat'] = 'bubus / bobus';
    $this->Substitutes['2_pl']['6_abl'] = 'bubus / bobus';
    break;

vas (Gefäß)

Besonderheiten: Pluralformen weichen ab.

Implementierung:

case 'vas':
    $this->Substitutes['2_pl']['2_gen'] = 'vasorum';  // statt vasum
    $this->Substitutes['2_pl']['3_dat'] = 'vasis';    // statt vasibus
    $this->Substitutes['2_pl']['6_abl'] = 'vasis';    // statt vasibus
    break;

supellex (Hausrat)

Besonderheit: Singulare tantum.

Implementierung:

case 'supellex':
    $this->clearPlural();
    break;

Defektive Nomina

Definition: Nomina, denen bestimmte Formen fehlen.

public $defectiva = [
    'vis', 'opes', 'fruges', 'preces', 'fas', 'nefas'
];

vis (Kraft, Gewalt)

Besonderheiten:

• Kein Genitiv Singular
• Kein Dativ Singular
• Defektiver Singular, regulärer Plural

Implementierung:

case 'vis':
    $this->Substitutes['1_sg']['2_gen'] = '';
    $this->Substitutes['1_sg']['3_dat'] = '';
    $this->Substitutes['1_sg']['4_akk'] = 'vim';
    $this->Substitutes['1_sg']['6_abl'] = 'vi';
    $this->Substitutes['2_pl']['2_gen'] = 'virium';
    break;

Vollständige Formen:

Kasus	Singular	Plural
Nom.	vis	vires
Gen.	-	virium
Dat.	-	viribus
Akk.	vim	vires
Vok.	vis	vires
Abl.	vi	viribus

opes (Macht, Mittel)

Besonderheiten:

• Primär Plurale tantum, aber defektiver Singular existiert
• Kein Nominativ Singular
• Kein Dativ Singular

Implementierung:

case 'opes':
    $this->Substitutes['1_sg']['1_nom'] = '';
    $this->Substitutes['1_sg']['2_gen'] = 'opis';
    $this->Substitutes['1_sg']['3_dat'] = '';
    $this->Substitutes['1_sg']['4_akk'] = 'opem';
    $this->Substitutes['1_sg']['6_abl'] = 'ope';
    $this->Substitutes['2_pl']['2_gen'] = 'opum';
    break;

Vollständige Formen:

Kasus	Singular	Plural
Nom.	-	opes
Gen.	opis	opum
Dat.	-	opibus
Akk.	opem	opes
Vok.	-	opes
Abl.	ope	opibus

fas, nefas

Besonderheiten: Indeklinabel, nur Nominativ und Akkusativ.

---

Morphologie-Struktur

JSON-Hierarchie

Die Morphologie eines Nomens wird als hierarchisches JSON gespeichert. Die erste Ebene ist der Numerus, die zweite Ebene der Kasus.

Struktur:

{
  "1_sg": {
    "1_nom": "Form",
    "2_gen": "Form",
    "3_dat": "Form",
    "4_akk": "Form",
    "5_vok": "Form",
    "6_abl": "Form"
  },
  "2_pl": {
    "1_nom": "Form",
    "2_gen": "Form",
    "3_dat": "Form",
    "4_akk": "Form",
    "5_vok": "Form",
    "6_abl": "Form"
  }
}

Schlüssel-Konventionen

Numerus:

• 1_sg = Singular
• 2_pl = Plural

Kasus:

• 1_nom = Nominativ
• 2_gen = Genitiv
• 3_dat = Dativ
• 4_akk = Akkusativ
• 5_vok = Vokativ
• 6_abl = Ablativ

Beispiel: amica, ae f. (die Freundin)

Datenbankinhalt:

{
  "1_sg": {
    "1_nom": "amica",
    "2_gen": "amicae",
    "3_dat": "amicae",
    "4_akk": "amicam",
    "5_vok": "amica",
    "6_abl": "amica"
  },
  "2_pl": {
    "1_nom": "amicae",
    "2_gen": "amicarum",
    "3_dat": "amicis",
    "4_akk": "amicas",
    "5_vok": "amicae",
    "6_abl": "amicis"
  }
}

Zugriff auf Formen:

$morphArray = $nomen->getMorphArrayAttribute();

// Nominativ Singular
$nomSg = $morphArray['1_sg']['1_nom'];  // "amica"

// Genitiv Plural
$genPl = $morphArray['2_pl']['2_gen'];  // "amicarum"

Beispiel: dominus, i m. (der Herr)

Datenbankinhalt:

{
  "1_sg": {
    "1_nom": "dominus",
    "2_gen": "domini",
    "3_dat": "domino",
    "4_akk": "dominum",
    "5_vok": "domine",
    "6_abl": "domino"
  },
  "2_pl": {
    "1_nom": "domini",
    "2_gen": "dominorum",
    "3_dat": "dominis",
    "4_akk": "dominos",
    "5_vok": "domini",
    "6_abl": "dominis"
  }
}

Besonderheit: Vokativ Singular auf -e (nicht -us).

---

Morphologie-Generierung

Workflow

1. Instanziierung: NomenMorpher wird mit einem Nomen-Model instanziiert
2. Methodenwahl: autoMorph() wählt basierend auf fb_dklasse die passende Build-Methode
3. Regelanwendung: Deklinationsklasse bestimmt Grundendungen
4. Sonderregeln: Prüfung auf Sonderformen, Anomalia, Defectiva
5. Substitutionen: Spezielle Formen werden über $Substitutes Array überschrieben
6. Numerus-Bereinigung: Plurale/Singulare tantum werden bereinigt
7. JSON-Erstellung: Array wird zu JSON konvertiert
8. Speicherung: JSON wird in morph-Spalte gespeichert

autoMorph() Methode

Die zentrale Methode autoMorph() steuert die Morphologie-Generierung:

public function autoMorph()
{
    switch ($this->Nomen->fb_dklasse) {

        case 'a':
            $this->buildNomenADeklination();
            break;

        case 'o':
            if ($this->IsNeutrum() && !$this->IsNeutrumAufUs()) {
                $this->buildNomenODeklinationNeutrum();
            }
            else {
                if ($this->endung == 'er') {
                    $this->Substitutes = [
                        '1_sg' => [
                            '5_vok' => $this->lemma
                        ]
                    ];
                }

                $this->buildNomenODeklinationMaskulin();
                if ($this->IsNomenAufIus()) {
                    $this->Substitutes['1_sg']['5_vok'] = substr($this->lemma, 0, -3) . 'i';
                }
            }
            break;

        case 'u':
            if ($this->IsNeutrum()) {
                $this->buildNomenUDeklinationNeutrum();
            }
            else {
                $this->buildNomenUDeklinationMaskulin();
            }
            break;

        case 'e':
            $this->buildNomenEDeklination();
            break;

        case 'indekl':
            $this->buildNomenIndeklinabel();
            break;

        case '3dekl':
            // Komplexe Logik für 3. Deklination
            // (siehe Abschnitt "Dritte Deklination")
            $this->buildNomen3Deklination();
            break;
    }

    // Numerus-Bereinigung
    if ($this->IsPluraleTantum()) {
        $this->clearSingular();
    }
    if ($this->IsSingulareTantum()) {
        $this->clearPlural();
    }

    // Sonderformen-Handling (Anomalia, Defectiva)
    if ($this->IsAnomale()) {
        // ... spezifische Substitutionen
    }
    if ($this->IsDefectivum()) {
        // ... spezifische Substitutionen
    }

    $this->substituteForms();
}

Build-Methoden

Für jede Deklinationsklasse existiert eine eigene Build-Methode:

buildNomenADeklination()

private function buildNomenADeklination()
{
    $this->formen = [
        '1_sg' => [
            '1_nom' => $this->lemma,
            '2_gen' => $this->stamm . 'ae',
            '3_dat' => $this->stamm . 'ae',
            '4_akk' => $this->stamm . 'am',
            '5_vok' => $this->lemma,
            '6_abl' => $this->stamm . 'a',
        ],
        '2_pl' => [
            '1_nom' => $this->stamm . 'ae',
            '2_gen' => $this->stamm . 'arum',
            '3_dat' => $this->stamm . 'is',
            '4_akk' => $this->stamm . 'as',
            '5_vok' => $this->stamm . 'ae',
            '6_abl' => $this->stamm . 'is',
        ],
    ];
}

buildNomenODeklinationMaskulin()

private function buildNomenODeklinationMaskulin()
{
    $this->formen = [
        '1_sg' => [
            '1_nom' => $this->lemma,
            '2_gen' => $this->stamm . 'i',
            '3_dat' => $this->stamm . 'o',
            '4_akk' => $this->stamm . 'um',
            '5_vok' => $this->stamm . 'e',
            '6_abl' => $this->stamm . 'o',
        ],
        '2_pl' => [
            '1_nom' => $this->stamm . 'i',
            '2_gen' => $this->stamm . 'orum',
            '3_dat' => $this->stamm . 'is',
            '4_akk' => $this->stamm . 'os',
            '5_vok' => $this->stamm . 'i',
            '6_abl' => $this->stamm . 'is',
        ],
    ];
}

buildNomen3Deklination()

private function buildNomen3Deklination()
{
    $this->formen = [
        '1_sg' => [
            '1_nom' => $this->lemma,
            '2_gen' => $this->stamm . $this->kasusendungen['sg_gen'],
            '3_dat' => $this->stamm . $this->kasusendungen['sg_dat'],
            '4_akk' => $this->stamm . $this->kasusendungen['sg_akk'],
            '5_vok' => $this->lemma,
            '6_abl' => $this->stamm . $this->kasusendungen['sg_abl'],
        ],
        '2_pl' => [
            '1_nom' => $this->stamm . $this->kasusendungen['pl_nom'],
            '2_gen' => $this->stamm . $this->kasusendungen['pl_gen'],
            '3_dat' => $this->stamm . $this->kasusendungen['pl_dat'],
            '4_akk' => $this->stamm . $this->kasusendungen['pl_akk'],
            '5_vok' => $this->stamm . $this->kasusendungen['pl_vok'],
            '6_abl' => $this->stamm . $this->kasusendungen['pl_abl'],
        ],
    ];
}

Besonderheit: Die Endungen werden dynamisch über das $kasusendungen Array definiert, das je nach Unterklasse (vokalisch Gruppe 1, Gruppe 2, Gen. auf -ium) angepasst wird.

Substitutions-Mechanismus

Der $Substitutes Array ermöglicht das Überschreiben spezifischer Formen:

// Beispiel: Vokativ bei -ius Nomina
$this->Substitutes['1_sg']['5_vok'] = 'fili';  // statt 'filie'

// Beispiel: Neutrum-Akkusativ = Nominativ
$this->Substitutes['1_sg']['4_akk'] = $this->lemma;

// Anwendung aller Substitutionen
private function substituteForms()
{
    foreach ($this->Substitutes as $numeri => $cases) {
        foreach ($cases as $case => $sonderform) {
            $this->formen[$numeri][$case] = $sonderform;
        }
    }
}

---

Methoden

getLemmaInfo()

Generiert die Lemma-Info-Angabe basierend auf der Deklinationsklasse.

Zweck: Anzeige der Genitivform und weiterer Informationen im Wörterbuch.

Rückgabe: String mit Genitiv-Endung und optionalen Info-Angaben.

Implementierung:

public function getLemmaInfo()
{
    try {
        // a-Deklination: amica, ae
        if ($this->fb_dklasse === "a") {
            $GenitivEndung = $this->fb_bes_numerus === 'pltantum'
                ? ', arum'
                : ', ae';
            return $GenitivEndung . $this->getInfoColumn();
        }

        // o-Deklination: amicus, i / templum, i
        elseif ($this->fb_dklasse === "o") {
            $GenitivEndung = $this->fb_bes_numerus === 'pltantum'
                ? ', orum'
                : ', i';
            return $GenitivEndung . $this->getInfoColumn();
        }

        // u-Deklination: exercitus, -ūs
        elseif ($this->fb_dklasse === "u") {
            $GenitivEndung = $this->fb_bes_numerus === 'pltantum'
                ? ', -uum'
                : ', -ūs';
            return $GenitivEndung . $this->getInfoColumn();
        }

        // e-Deklination: res, rei
        elseif ($this->fb_dklasse === "e") {
            $GenitivEndung = $this->fb_bes_numerus === 'pltantum'
                ? $this->getMorphArrayAttribute()['2_pl']['2_gen']
                : $this->getMorphArrayAttribute()['1_sg']['2_gen'];
            return ', ' . $GenitivEndung . $this->getInfoColumn();
        }

        // 3. Deklination: mercator, mercatoris
        elseif ($this->fb_dklasse === "3dekl") {
            $GenitivEndung = $this->fb_bes_numerus === 'pltantum'
                ? $this->getMorphArrayAttribute()['2_pl']['2_gen']
                : $this->getMorphArrayAttribute()['1_sg']['2_gen'];
            return ', ' . $GenitivEndung . $this->getInfoColumn();
        }

        else {
            return '';
        }
    } catch (\Exception $exception) {
        GlossariumReporter::report(
            $this->lemma,
            "additional_lemma_info",
            Helpers::getUserIDOrDaemonID(),
            $this->wortart . '/' . $this->id,
            "Konnte keine AdditionalLemmaInfo erstellen: Probleme bei Lesen morphologischer Informationen!",
            get_class($this),
            $this->id
        );

        return '';
    }
}

Beispiele:

• amica → , ae
• arma (Plurale tantum, a-Dekl.) → , arum
• amicus → , i
• templum → , i
• exercitus → , -ūs
• res → , rei
• homo → , hominis
• corpus → , corporis

convertEigenname()

Konvertiert ein Nomen in einen Eigennamen.

Zweck: Wenn ein Nomen als Eigenname identifiziert wird (z.B. Personenname, Ortsname), kann es in die Tabelle glossarium_eigennamen verschoben werden.

Implementierung:

public function convertEigenname()
{
    $Eigenname = Eigenname::create([
        'lemma' => $this->lemma,
        'info' => $this->info,
        'fb_stamm' => $this->fb_stamm,
        'fb_dklasse' => $this->fb_dklasse,
        'fb_genus' => $this->fb_genus,
        'fb_bes_numerus' => $this->fb_bes_numerus,
        'bedeutung' => $this->bedeutung,
        'morph' => $this->morph,
        'status' => $this->status,
    ]);

    $this->forceDelete();
}

Prozess:

1. Neues Eigenname-Model mit allen Daten erstellen
2. Original-Nomen endgültig löschen (forceDelete, nicht soft delete)

Anwendungsfall:

• Caesar (ursprünglich Nomen, dann als Eigenname erkannt)
• Roma (die Stadt Rom)

IsValid()

Prüft, ob alle erforderlichen Felder für die Morphologie ausgefüllt sind.

Rückgabe: Boolean (true wenn valide, false wenn nicht)

Implementierung:

public function IsValid(): bool
{
    if (
        ! empty($this->lemma) &&
        ! empty($this->fb_stamm) &&
        ! empty($this->fb_genus) &&
        ! empty($this->fb_dklasse)
    ) {
        return true;
    }

    return false;
}

Verwendung:

if ($nomen->IsValid()) {
    $nomen->morph();  // Morphologie generieren
} else {
    // Fehlende Felder melden
}

---

Verwendungsbeispiele

Neues Nomen erstellen und morphologisieren

use App\Models\Nomen;

// 1. Nomen erstellen
$amica = Nomen::create([
    'lemma' => 'amica',
    'fb_stamm' => 'amic',
    'fb_dklasse' => 'a',
    'fb_genus' => 'f',
    'bedeutung' => 'die Freundin',
]);

// 2. Morphologie generieren
$amica->morph();

// 3. Status prüfen
echo $amica->status;  // 2 (morphologisiert)

Nomen mit Plurale tantum

$arma = Nomen::create([
    'lemma' => 'arma',
    'fb_stamm' => 'arm',
    'fb_dklasse' => 'o',
    'fb_genus' => 'n',
    'fb_bes_numerus' => 'pltantum',
    'bedeutung' => 'die Waffen',
]);

$arma->morph();

// Singular-Formen sind leer
$morphArray = $arma->getMorphArrayAttribute();
echo $morphArray['1_sg']['1_nom'];  // "" (leer)
echo $morphArray['2_pl']['1_nom'];  // "arma"

Formen abrufen

$nomen = Nomen::find(1);

// Morphologie als Array
$morphArray = $nomen->getMorphArrayAttribute();

// Spezifische Form abrufen
$genitivSingular = $morphArray['1_sg']['2_gen'];

// Alle Formen als Collection
$alleFormen = $nomen->alle_formen;

foreach ($alleFormen as $form) {
    echo $form . "\n";
}

Lemma-Info anzeigen

$nomen = Nomen::where('lemma', 'dominus')->first();

echo $nomen->lemma;           // "dominus"
echo $nomen->getLemmaInfo();  // ", i"
echo $nomen->lemma_info;      // ", i" (via Accessor)

// Vollständige Anzeige
echo $nomen->lemma . $nomen->lemma_info . ' ' . $nomen->fb_genus . '.';
// "dominus, i m."

Nomen suchen

// Einzelnes Nomen finden
$amica = Nomen::where('lemma', 'amica')->first();

// Alle Nomina einer Deklinationsklasse
$aDeklination = Nomen::where('fb_dklasse', 'a')->get();

// Nur Feminina
$feminina = Nomen::where('fb_genus', 'f')->get();

// Pluralia tantum
$pluraliaTantum = Nomen::where('fb_bes_numerus', 'pltantum')->get();

// Morphologisierte Nomina
$morphologisiert = Nomen::where('status', 2)->get();

Performance-optimierte Abfrage

// Ohne Morphologie-Daten (schneller)
$nomina = Nomen::select(['id', 'lemma', 'bedeutung', 'fb_dklasse'])
    ->exclude(['morph'])
    ->get();

// Mit Morphologie
$nomenMitMorph = Nomen::find(1);
$formen = $nomenMitMorph->getMorphArrayAttribute();

Soft Delete

$nomen = Nomen::find(1);

// Soft Delete
$nomen->delete();  // deleted_at wird gesetzt

// Gelöschte einbeziehen
$allNomina = Nomen::withTrashed()->get();

// Nur gelöschte
$geloeschte = Nomen::onlyTrashed()->get();

// Wiederherstellen
$nomen->restore();

// Endgültig löschen
$nomen->forceDelete();

Verweise verwalten

$nomen = Nomen::find(1);

// Verweise von diesem Nomen zu anderen
$verweiseFrom = $nomen->verweise_from;

// Verweise auf dieses Nomen
$verweiseTo = $nomen->verweise_to;

// Formverweise
$verweiseToFormen = $nomen->verweise_to_formen;

Sachfelder zuordnen

$nomen = Nomen::find(1);

// Sachfelder abrufen
$sachfelder = $nomen->sachfelder;

// Sachfeld zuordnen
$sachfeld = Sachfeld::find(5);
$nomen->sachfelder()->attach($sachfeld);

// Sachfeld entfernen
$nomen->sachfelder()->detach($sachfeld);

---

Beispieldaten

amica, ae f. (die Freundin)

Datenbankfelder:

'id' => 1,
'lemma' => 'amica',
'info' => '',
'fb_stamm' => 'amic',
'fb_dklasse' => 'a',
'fb_genus' => 'f',
'fb_bes_numerus' => '',
'bedeutung' => 'die Freundin',
'bedeutungen_alle' => '',
'morph_mode' => 0,
'status' => 2,

Morphologie (JSON):

{
  "1_sg": {
    "1_nom": "amica",
    "2_gen": "amicae",
    "3_dat": "amicae",
    "4_akk": "amicam",
    "5_vok": "amica",
    "6_abl": "amica"
  },
  "2_pl": {
    "1_nom": "amicae",
    "2_gen": "amicarum",
    "3_dat": "amicis",
    "4_akk": "amicas",
    "5_vok": "amicae",
    "6_abl": "amicis"
  }
}

Deklinationstabelle:

Kasus	Singular	Plural
Nom.	amica	amicae
Gen.	amicae	amicarum
Dat.	amicae	amicis
Akk.	amicam	amicas
Vok.	amica	amicae
Abl.	amica	amicis

domina, ae f. (die Herrin)

Datenbankfelder:

'id' => 2,
'lemma' => 'domina',
'info' => '',
'fb_stamm' => 'domin',
'fb_dklasse' => 'a',
'fb_genus' => 'f',
'fb_bes_numerus' => '',
'bedeutung' => 'die Herrin',
'bedeutungen_alle' => '',
'morph_mode' => 0,
'status' => 2,

Morphologie (JSON):

{
  "1_sg": {
    "1_nom": "domina",
    "2_gen": "dominae",
    "3_dat": "dominae",
    "4_akk": "dominam",
    "5_vok": "domina",
    "6_abl": "domina"
  },
  "2_pl": {
    "1_nom": "dominae",
    "2_gen": "dominarum",
    "3_dat": "dominis",
    "4_akk": "dominas",
    "5_vok": "dominae",
    "6_abl": "dominis"
  }
}

Deklinationstabelle:

Kasus	Singular	Plural
Nom.	domina	dominae
Gen.	dominae	dominarum
Dat.	dominae	dominis
Akk.	dominam	dominas
Vok.	domina	dominae
Abl.	domina	dominis

corpus, corporis n. (der Körper)

Datenbankfelder (exemplarisch):

'lemma' => 'corpus',
'fb_stamm' => 'corpor',
'fb_dklasse' => '3dekl',
'fb_genus' => 'n',
'fb_bes_numerus' => '',
'bedeutung' => 'der Körper',

Morphologie (JSON):

{
  "1_sg": {
    "1_nom": "corpus",
    "2_gen": "corporis",
    "3_dat": "corpori",
    "4_akk": "corpus",
    "5_vok": "corpus",
    "6_abl": "corpore"
  },
  "2_pl": {
    "1_nom": "corpora",
    "2_gen": "corporum",
    "3_dat": "corporibus",
    "4_akk": "corpora",
    "5_vok": "corpora",
    "6_abl": "corporibus"
  }
}

Deklinationstabelle:

Kasus	Singular	Plural
Nom.	corpus	corpora
Gen.	corporis	corporum
Dat.	corpori	corporibus
Akk.	corpus	corpora
Vok.	corpus	corpora
Abl.	corpore	corporibus

Besonderheiten:

• 3. Deklination, konsonantisch
• Neutrum: Nom. = Akk. = Vok. in jedem Numerus
• Plural auf -a (Neutrum-Regel)

---

Zusammenfassung

Die Nomina im Glossarium-System von Hermeneus bilden eine komplexe und linguistisch präzise Implementierung der lateinischen Substantivdeklination. Die wichtigsten Merkmale sind:

1. Fünf Deklinationsklassen (a, o, u, e, 3dekl) plus indeklinable Formen
2. Automatische Morphologie-Generierung basierend auf linguistischen Angaben
3. Dritte Deklination mit differenzierter Behandlung (konsonantisch vs. vokalisch)
4. Sonderformen-Handling für anomale und defektive Nomina
5. Numerus-Besonderheiten (Plurale tantum, Singulare tantum)
6. Hierarchisches JSON für morphologische Daten (Numerus → Kasus)
7. Konvertierung zu Eigennamen für Spezialfälle
8. Umfassende Validierung und Fehlerbehandlung

Die Implementierung orientiert sich an klassischen lateinischen Grammatiken (insbesondere Rubenbauer/Hofmann) und bietet eine solide Grundlage für alle textanalytischen und didaktischen Funktionen der Hermeneus-Plattform.

---

Weiterführende Dokumentation:

• Glossarium-Übersicht
• Eigennamen
• Morphologie-System

Externe Referenzen:

• Rubenbauer/Hofmann: Lateinische Grammatik (RH)
• Kühner-Stegmann: Ausführliche Grammatik der lateinischen Sprache