Negation in U niversal D ependencies (2025)

Abstract: In this paper we study the representation of negation in UD treebanks. We show that the existing annotations are often inconsistent with the guidelines and that there are ill-motivated differences in annotation of constructions across and even within languages. Moreover, we argue that even if the annotation of the two negation-related features ( \texttt{Polarity=Neg} and \texttt{PronType=Neg} ) were consistent, these two features would be inadequate for straightforwardly expressing the semantics of negation because they relate to the word level only and hence to form rather than meaning. We therefore propose to add two features, \texttt{Negated=+} and \texttt{DoubleNegated=+} , which directly encode when a predicate is semantically under negation, and thereby allow a straightforward semantic interpretation of a UD parse in terms of negation.

## introduction negation is a complex but ubiquitous phenomenon in natural language, involving constraints across the syntax-semantics interface. in this paper, we address the representation of negation in universal dependencies (ud: @xcite , point out inconsistencies in the current representation, and make a suggestion for how it can be improved, including an implementation that will create this representation for english ud. our ultimate motivation for this work is the use of ud in semantic parsing, i.e. the translation of ud syntactic annotations into semantic representations. in section 2 we discuss this use case for ud and what it entails -especially for feature representation, which is much less standardised than dependency relations. section 3 then gives a (simplified) overview of the challenges this task raises at the syntax-semantics interface. negation is a wide field and we therefore choose to focus on some selected cases all involving sentential negation. unfortunately, the existing ud protocol and its current implementations in the ud treebanks leave something to be desired when it comes to helping with this challenge. in section 4 we show that the current annotation of negation is inconsistent across treebanks, and sometimes even within single treebanks. in section 5 we show that even if the annotation was consistent, the word-level, morphology-dominated features currently used in the ud annotation scheme make it challenging to introduce negation compositionally in the semantics. in section 6, we propose an addition to the ud annotation scheme whereby features are added to the predicate itself to indicate whether it is negated (or doubly negated). using the graph rewriting formalism (grew: @xcite , we provide a ruleset which can add these features automatically to ud annotations for english. however, we suggest that these features should be included in the standard annotation scheme in future, in keeping with recent proposals to add phrase-or clause-level features to ud annotations @xcite . ## motivation there is a tradition of work using ud representations to create semantic representation @xcite @xcite . most of this work focuses on the information available in the tree structure and the labels, which clearly provide important clues to the structure of the semantic representations as well as to the semantic relations between different words. but features also have an important role to play, since they provide language neutral representations of certain aspects of lexical information, most often in function words. for example, in the absence of a featural representation of negation, a semantic parser will need language-specific lexical information about what words express negation and how. while high quality semantic parsing will likely re-quire fine-grained language-specific information in any case, the process can clearly be simplified to the extent that certain lexically-encoded aspects of meaning can be read off the features in a language neutral way. this is, however, not possible with the current ud features. consider tense, for example. despite the guidelines' claim that tense "is a feature that specifies the time when the action took/takes/will take place", foot_0 the actual features that we find in ud reflect morphological rather than semantic facts. part of the reason this is so is that features in ud are necessarily word-bound, and automatic annotation procedures tend not to take the surrounding context into account, so that properties which arise constructionally or periphrastically are not represented. as a concrete example, consider the value of the tense feature on an english verb in the ud treebanks -this depends entirely on the verb's form, and not on its meaning, so provided gets @xmath0, a (present) perfect (2), or a passive of any tense (3): it is possible to compute tense values for the verbal complexes in (3), by inspecting other features such as verbform and voice, but this cannot be done without detailed, language-specific knowledge about the english annotation. this approach is therefore not amenable to large-scale typological investigations, which is one of the oft-cited use cases for ud. it would be possible to solve this problem "compositionally" by defining universal resolution rules for sets of features coming from both the lexical verb and the auxiliary. a more direct route is to add annotations of constructions on top of ud, as argued for by @xcite . here we will take a slightly different route, by allowing head features to represent features of the whole construction. this is largely equivalent to constructional annotations for constructions that have a clear head, which is the case for both verb-auxiliary constructions and verb-negation constructions. foot_1 adding features to the head also has a practical advantage by making it possible to directly compare constructional and lexical expressions (although one could of course just admit single word constructions). our approach also aligns with the goals of the unidive shared task on morpho-syntactic parsing (msp). 3 following ud, msp makes a sharp divide between lexical words and function words. the latter are always dependents in ud and can therefore be ignored in the tree structure. instead they contribute features to their heads. so, in the msp annotation of will not go, only go is a node in the tree; will and not contribute fut and neg to the features of go. although we do not care about the tree structures and what counts as a node here, we adopt the same principle as msp that function words can contribute features to their head. this move is in fact what makes it possible for us (and msp) to take advantage of a much-discussed feature of ud, that function words are always dependents. the main argument for this approach is that it makes annotations more similar across languages that use analytic and synthetic means of expression. as the ud guidelines put it, foot_3 "preferring content words as heads maximizes parallelism between languages because content words vary less than function words between languages. in particular, one commonly finds the same grammatical relation being expressed by morphology in some languages or constructions and by function words in other languages or constructions [. . . ]". however, the primacy of lexical words only makes the tree structures similar, not the features, unless we let dependents contribute features to their head. consider the example discussed by de @xcite shown in figure 1 . the tree topology is identical modulo function words, but the feature representation is not: in swedish, the subject np bears both a @xmath1, whereas the english subject np only has the number feature. this means the ud representation cannot be used to study plural, definite noun phrases across languages without some further post-processing. in this case, the rule that is needed to unify the two representations is simple (move the definite feature from the functional dependent to its lexical head), but as we have seen for tense, and as we will see for negation in this paper, this is not always the case. while the percolation of features from functional dependents to lexical heads, as made explicit in msp, can be seen as a sort of default, the rules of feature construction can be quite involved and often cannot be stated without deep knowledge of the language in question, which is why it should be done by annotators, and not by end users of ud treebanks. ## the challenges of negation with all this said, our goal is to explore to what extent the morphosyntactic representation of negation in ud treebanks allows for an adequate semantic representation of negation in a uniform manner across languages, and to propose amendments to the ud treatment of negation that would facilitate this. we do not want to commit to a particular meaning representation, so in the following we discuss the inference patterns that negated sentences give rise to, largely following the presentation in @xcite ). we do not explicitly discuss the role of tense, but assume, following @xcite , that sentences are interpreted relative to some particular time interval that is anaphorically determined in the context, and that this interval is held constant from premises to conclusions in inferencing. let us first consider the simple negated transitive clause in (4): we take it that this sentence licenses an inference to the disjunction of (5a-c): this is a fairly weak semantics for negation, but it is all that can be attributed to the linguistic information alone. exactly which of the disjuncts turn(s) out to be true will be determined by context and world knowledge. notice that the negation scopes over both the verb's event description and the semantic roles associated with the event. we take it that clausal negation (as opposed to so-called constituent negation) always negates these parts of the sentence: that is what it means for negation to be clausal. however, clausal negation may or may not scope over adjuncts. adjunct scope consider the following extended variant of (4). world knowledge tells us that in (6), the most plausible reading is that one or more of the disjuncts that we saw in (5) is true, and the because-clause gives the reason why this is so. that is, negation does not scope over the adjunct. but now consider the extension in (7) (7) jason didn't eat the porridge because he was hungry. here, world knowledge tells us that it is likely none of the disjuncts in (5) is true; instead only the causal relation between john's hunger and his eating is denied. in other words, he ate the porridge, but not because he was hungry. the linguistic structure itself is insufficient to distinguish between these two cases, and this is once again a situation where context and world knowledge will guide interpretation. negative indefinites another challenging phenomeon is the fact that, in addition to marking negation on the verb, many languages allow negation to be expressed with so-called "negative indefinites" @xcite : ch. 8), which combine sentence negation and an indefinite (existential) quantifier. hence (8a) can be paraphrased as (8b). ( 8) a. jason ate nothing. b. it was not the case that jason ate something. an adequate representation of negation in these cases must be able to account for this equivalence, i.e. that the negation is clausal in spite of being marked only on the object quantifier. in other words, we want nothing to contribute a clausal negation, represented on the clausal head, while at the same time filling the object position. this is a direct challenge to the the strict division adopted by msp, where function words contribute features to their heads and lexical words are nodes in the tree: words like nothing need to be able to do both. ## negation in the ud treebanks in this section we explore the variable representations of negation in the ud treebanks (in the 2.15 release: zeman et al. 2024). it will be seen that there are unfortunate inconsistencies within and across languages, even taking into account typological variation. ideally, we would like the ud parse to provide us with sufficient information to produce a schematic meaning representation of the sentence, with at least the right logical structureeven though specific predicate names or thematic relations will ultimately have to be retrieved from a lexicon (see e.g. @xcite for proposals along these lines). however, inconsistencies and lacunae in the annotations make this more challenging than it needs to be, and negation proves to be a case in point. ud provides two relevant features for representing negation: @xmath2. according to the guidelines, 5 the former is used for "negating particles and words which inflect for polarity (verbs, adjectives, etc.)", including english not, nor, and no as an interjection, while the latter is used for negative pronouns such as english 5 see https://universaldependencies. org/u/feat/prontype.html#neg and https: //universaldependencies.org/u/feat/polarity . html. when it comes to straightforward clausal negation, the treebanks are largely uniform in correctly employing @xmath3, whether that be the predicate itself, inflected with a negative affix, as in e.g. persian, or a dependent of the negated predicate, as in e.g. norwegian -see figure 2 there are exceptions even with this most basic kind of negative construction, however. the ud italian-isdt treebank, for example, uses @xmath4, contrary to the annotation guidelines, and only uses @xmath5. this inconsistency between treebanks is an issue for semantic interpretation, since there is no single feature which is reliably associated with clausal negation. a different challenge comes from treebanks such as ud english-ewt, which make no use of @xmath6, such that clausal negation is simply not marked in the syntactic analysis. in fact, only 224 of the 296 treebanks in the 2.15 release (76%) use the @xmath7, and only 99 (33%) use the @xmath8. overall, 62 treebanks (21%) use neither feature, meaning over a fifth of the treebanks do not represent negation of any kind, even though negation is a phenomenon present in every natural language (zeijlstra 2020: 426). 6 one area of much more cross-treebank consistency is in the treatment of negative conjunctions like neither and nor or their translation equivalents. unfortunately, this is because treebanks consistently fail to annotate these words with any feature that indicates a negative polarity. this is once again contrary to the annotation guidelines -which explicitly mention english nor as meriting the feature @xmath9, for example -and is also plainly unsatisfactory from the standpoint of interpretation: (9a) is truth-conditionally equivalent to (9b), and therefore just as clearly negated, but only the latter will contain a @xmath10: figure 3 : the two features in ud italian-isdt ative determiners, for example -the equivalent of english no (as in we have no bananas) -ought to be annotated with a @xmath11. and some treebanks do just this, such as ud persian-seraji. but we also find such words annotated with only a @xmath12, as in ud norwegian-bokmaal, or with neither feature, as in ud turkish-boun. part of the challenge here comes from the fact that in negative concord languages these determiners can appear under negation, such that they have the (negative polarity item) meaning 'any' (as in we do not have any bananas). but, as noted above, treebanks generally choose a single annotation for a particular word regardless of context, and this therefore leads to inaccuracies in both directions. for example, turkish hic ¸can have a directly negative meaning but is consistently annotated as if it cannot, while the persian cognate hīč is explicitly marked as negative but can equally well have the npi meaning. treatment of negative indefinites also varies substantially, even within a single language. we take ud english-gum as a case study. on the other hand, we do not understand the decision to distinguish nobody from nothing by the former's lack of a @xmath17; it is not clear to us what linguistic distinction this could be intended to capture. in sum, the existing ud treebanks handle negation in an inconsistent manner, both across and within treebanks. because of this, neither of the two negation-related features can be given a consistent semantic interpretation. this is problematic for our goal of providing a skeletal semantic representation of the logical structure of a sentence, since negation plays an important role in determining this structure. ## insufficiency of the annotation scheme lack of annotation consistency makes universal interpretation directly from the features impossible. certainly, clarifying the intended usage of both @xmath18. nevertheless, we believe even treebanks perfectly annotated according to the existing guidelines would be inadequate as the basis for semantic interpretation when it comes to negation. let us see why. the most elementary clausal negation is associated with the feature @xmath19. we might therefore suggest that this feature triggers the introduction of negation in the semantics, so that (10) has the interpretation described in section 3: there is no 'knowing' situation with the speaker as the experiencer. what about the other feature, @xmath20, which lack negative concord, this also sometimes needs to introduce clausal negation into the semantics: the sentence in ( 11 ) is, at least truth-conditionally, equivalent to ( 12 ), which has an explicit clausal negation: 8 (12) we didn't see anybody. so it seems reasonable to assume that @xmath21. what is more, when both features are present, we get a double-negation reading (in non-negative concord varieties of english, at least): we could, therefore, parametrise our semantic interpretation rule so that @xmath22, but does not do so in negative concord languages. unfortunately, this is not the whole story. negative quantifiers in nc languages do sometimes introduce clausal negation into the semantics, when they are in subject position; (16) means 'nobody knows how to score goals', i.e. 'it is not the case that somebody knows how to score goals.': so we cannot simply parametrise the @xmath23, since in fact it is sometimes still needed. ## proposal negation is in a similar bind to tense, as discussed above (in section 2): the current annotations really relate to form alone, which means that, for example, no accommodation is made for (a) the difference between nc and non-nc languages, and (b) the contrast between different uses of n-words within a single language. our solution is to introduce a new feature, @xmath24, which is annotated directly on a predicate which is semantically under negation, regardless of any morphosyntactic concerns. in the next section we explain how this can be interpreted, but for now we can observe that such a move also contributes to an increased universality in representations, since it establishes a clearer parallel between synthetic and analytic expressions of negation: in figure 4 , for example, we see that the english and czech verbs both bear the @xmath25, even though the existing @xmath26. in addition to the @xmath27, we also add a feature @xmath28, for sentences like we didn't see nobody in non-nc varieties, where this truly expresses a double negation. an alternative would be to simply omit the @xmath29, on the basis that the semantics is equivalent to that of positive we saw somebody, but we choose to include more information rather than make the decision that double negations should be interpreted exactly the same way as un-negated sentences -after all, they are clearly pragmatically marked, and we prefer to leave open the space of analytical possibilities. @xcite suggest that double negation actually consists of one instance of clausal negation and one of constituent negation, and that multiple instances of a single type are not in fact possible. this may be so, but ud does not always enable us to make the distinction between these two types of negation explicit in the parse, so we use the feature @xmath30. for future annotation projects, we would advocate for adding these annotations from the start, and preferably manually, in order to capture complex interactions or edge cases. but given a little language-specific information about different negative lemmata, they can also be added automatically, and we have prepared a script to do just this for the english treebanks, using the graph rewriting formalism (grew: @xcite ). 9 the @xmath31: the presence of each of these features adds a new instance of negation to the semantics, one which scopes over the sub-tree rooted by the node bearing the annotation. this is a fairly simplistic semantics for negation, but has the virtue of being able to be read directly off the ud tree. it will give rise to an interpretation which is consistent with but usually be weaker than the fully contextually-resolved meaning, as discussed in section 3. as mentioned above, a clausal negation like (17) entails the disjunction in ( 18 ): (17) jason did not eat the porridge @xmath32. no eating event took place. b. the agent of the eating event was not jason. c. the theme of the eating event was not the porridge. we can rephrase this disjunction of negations as a conjunction under a single negation (via de morgan's law): (19) it was not the case that a. an eating event took place, and b. the agent of the eating event was jason, and c. the theme of the eating event was it is clear to see how this interpretation follows from the addition of the @xmath33, since these conjuncts correspond to the semantic contributions of the verb itself, the nsubj dependency, and the obj dependency, respectively, i.e. the subtree rooted in the eat node which hosts the feature. of course, context may well provide us with the necessary information to determine a stronger meaning: perhaps there was a porridge-eating event, but jason was not the agent, so that only the second conjunct is actually false. nevertheless, the ud parse will never give us sufficient information to determine this, so it is best to provide a weak but at least consistent semantics: even if it is true that a porridge-eating event took place with isabella as the agent, this does not diminish the truth of ( 19 ), since the conjunction of statements remains false. we apply exactly the same logic to more obviously ambiguous sentences like (20): here the most plausible interpretation, given our world knowledge, is that it is only the cause relation between jason's hunger and his eating the porridge which is denied. but this state of affairs is still consistent with the claim that there was no porridge-eating event with jason as agent and his hunger as cause. since the syntax alone does not tell us which or how many of these conjuncts are true or false, it is reasonable for our syntax-driven interpretation to provide only a weak semantics, allowing the context to narrow it down if possible. it is much easier to see how context might add additional information that narrows the space of possible interpretations, for example, than how it could broaden an already too-narrow interpretation. an advantage of adding our annotation to the verb itself rather than the explicitly negative element, which may be a dependent, is that often the verb itself should be under the scope of negation, even when the negation is introduced lower down in the tree. sentence (21) is a case in point: the sentence in (21) should most plausibly not mean there was an eating event with no theme, for example, but rather that there was no eating event (with some theme) at all. this requires us to introduce the negation meaning at the verb, rather than just at the quantifier nothing, which is where the only negation-related feature would be found in the vanilla annotation. notice that this implies that a negative quantifier like nothing makes the same contribution to the compositional semantics as a positive quantifier like something. this means that we can treat nc and non-nc languages the same in this regard; the only difference is a syntactic one, namely when it is that negative quantifiers induce the presence of a @xmath34. in a language like english, they always will; in a language like spanish they will do so only when in subject position. ## conclusion ud's features are restricted to the word level, and this often means that annotators base their decisions on form instead of meaning. this is problematic if one wants to derive a semantic representation from a ud one, since many features which 'ought' to directly express semantic attributes do not. negation is a case in point, which we have focussed on here. the existing treebanks apply the annotation guidelines incompletely and inconsistently for the two negation-related features (@xmath35, but even if they did not, these two features would be inadequate for straightforwardly expressing the semantics of negation. we propose the addition of two features, @xmath36, which directly encode when a predicate is semantically under negation. if these are added as part of the annotation process, they will enable a straightforward semantic interpretation of a ud parse in terms of negation, at least for the cases we discussed here, namely basic clausal negation, adjunct scope, and negative quantifiers.