Ontological Types for LUs

Definition

Each LU (a lemma + sense pairing) carries an ontological type: a coarse, semantic classification of the concept's stable identity. It is not a part-of-speech and is orthogonal to the LU's UD POS tag. It tracks the DUL Event identity — what kind of thing the concept is — independent of syntactic realization or constructional construal.

The type is written as a suffix on the LU:

destruição.event      silêncio.state
inteligência.attribute     cadeira.entity

The inventory (intentionally small and coarse)

The ontological-type vocabulary is deliberately narrower than the namespace vocabulary. It does not mirror namespace names.

.relation is added as a distinct concept-identity, not as a mirror of the @relational namespace. A relation is genuinely none of the four kinds above — not a thing (.entity), not a condition of one entity (.state), not an intrinsic quality of one entity (.attribute), not an occurrence (.event) — it is a tie between relata, a top-level ontological category in its own right. It earns its place only because it also satisfies the asymmetry of §3: a .relation LU spreads across @relational, @stative (relational states), and @situation (spatial/temporal image-schemas), so the §4 check can actually discriminate.

Keep the set small — its value comes from coarseness. Add a further type only when it names a genuinely distinct concept-identity and spreads across more than one namespace (the §3 asymmetry test); never add one merely because a namespace exists.

Why coarse, and the suffix-vs-namespace asymmetry

The asymmetry is the most important property of this layer. The namespace is the fine-grained view (the Situation/Description); the ontological type is the coarse identity class (the Event). Hence:

• destruição.event may be evoked by a @causative frame (destruction as cause), a @transition frame (destruction as change of state), and a @stative frame (destruction as resulting condition) — all without contradiction and without splitting the concept. The suffix stays .event throughout.
• Genuine type ambiguity does split the LU: silent.state (entered a state, ficar em silêncio) vs. silent.attribute (a personality trait, é silencioso) are two LUs for one lemma, disambiguated by the annotator against a real sentence.

A useful diagnostic for participle-derived candidates: if the state is the FORMAL-role residue of an event the concept already contains (a nominalised event exists — cansaço for cansado, casamento for casado), it is .state. If no such event underlies it and the condition is intrinsic, it is .attribute.

A diagnostic for the .relation vs. .entity boundary (the relational-role nouns — pai, sócio, vizinho): apply the isolation / arity test from the Relational classification entry. If the concept needs two or more relata to make sense and has a converse (pai-de ↔ filho-de, posse ↔ pertence-a), it is .relation. If it names a thing or role you can refer to standalone (pai as a person who walked in), it is .entity. The same lemma may yield two LUs: pai.entity (the individual) vs. pai-de.relation (the kinship tie).

What this layer validates (and what it cannot)

The type licenses a class-compatibility check: does the frame's namespace admit this ontological class at all?

Spatial/temporal relations in @situation (image-schemas) also take .relation, but @situation's full admit-set is out of scope here — its meta-frame, like @relational's, is deferred. This row pair extends Layer 1 coverage to relational concepts; it does not imply @relational is fully modelled at Layer 2.

• Catches cross-class category errors: an .attribute LU in an eventive frame, an .entity LU in a stative frame, a .relation LU in a causative frame. Automatable, high-precision.
• Cannot catch within-class errors: it is silent on @causative vs. @inchoative vs. @action, because all admit .event. The empirical case proves this — aquecer.v [Causar_mudança_de_temperatura] and aquecer.v [Mudança_de_temperatura] are both .event; the class check correctly passes both and says nothing about which is right.
• Cannot catch wrong-sense errors: only the annotator choosing between silent.state and silent.attribute against a sentence can.

Within-class evaluation is the job of Layer 2 (see Eventive Namespaces, §2).