Predicates and entities in A bstract M eaning R epresentation (2023)

Abstract: Nodes in Abstract Meaning Representation (AMR) are generally thought of as neo-Davidsonian entities. We review existing translation into neo-Davidsonian representations and show that these translations inconsistently handle copula sentences. We link the problem to an asymmetry arising from a problematic handling of words with no associated PropBank frames for the underlying predicate. We introduce a method to automatically and uniformly decompose AMR nodes into an entity-part and a predicative part, which offers a consistent treatment of copula sentences and quasi- predicates such as brother or client.

## introduction over the past decade, graph-based semantic representation formalisms have gained a lot of attention, with abstract meaning representation (amr) arguably leading the trend (banarescu et al., 2013; knight et al., 2021). amr takes a dependency approach to meaning representation, using labeled directed acyclic graphs (incidentally called abstract meaning representations). labeled graph nodes represent concepts, while labeled directed edges represent the roles that concepts play in relation to others. for instance, in the sentence a girl likes herself, the entity concepts denoted by the noun girl plays two roles (agent and theme, parsons, 1990) in the eventuality concept denoted by the verb likes, which is represented by the amr in figure 1 , both as (a) a graph and (b) a tree in penman notation (mann, 1983). the root of the graph is indicated by double boundaries. note the use of co-indexed variables in the tree to express graph reentrance. amr relies whenever possible on propbank's frames (palmer et al., 2005) for thematic role labeling (in this case, the frame likes-01), hence the use of arg0 and arg1 rather than agent and theme. the root of an amr serves as "a rudimentary representation of overall focus" (banarescu et 2019 ). following amr guidelines, an existential sentence like there is a girl who likes herself or a phrase like a girl who likes herself would be associated the same representation, shown in figure 2 , which differs from the one in figure 1 only by its root. figure 2 also illustrates how inverse roles like arg0-of are used to unfold a directed graph as a tree from a designated root. amr, like other formalisms historically linked to natural language generation (e.g., meaning-text theory, mel'čuk, 1973, 2016), departs from logical meaning representations insofar as it comes with no notion of bound variable or scope. the semantic treatment of determiners and adverbs closely mirrors their treatment in dependency syntax, as they simply introduce a polarity or quantity role in the concept denoted by the word they modify. overall, amr aims at a transparent representation of predicate-argument structure independent from syntactic contingencies 1 and leaves aside other as-pects of logical structure, most notably scoping phenomena induced by quantification, negation or modality. as a result, amr offers a simplified formal apparatus for meaning representation, yielding better consistency among annotators, and effective comparison metrics for comparing semantic annotations. @xcite these operational and computational benefits however come at the cost of lacking a modeltheory (or a proof-theory, for that matter). this might be unsatisfying empirically or theoretically: empirically, because a formalisation of entailment or equivalence between different amrs might help downstream tasks or resolve annotation conflicts, and theoretically, because one might want semantic descriptions to describe the recursive relationship between semantic components and the world to count as more than paraphrases of the original sentences (davidson, 1967). for these reasons, translations of large fragments of amr into logic have been proposed (bos, 2016; lai et al., 2020). while discussions of amr's relationship to logical or model-theoretic approaches mostly revolve around questions of quantifier scope, in this paper, we are instead concerned with the type of object that amr nodes denote. our aim is to answer the following: do amr nodes always denote entities (objects, events, or states), or do they sometimes denote properties or propositions? do they denote several of these things at once? can one consistently assign a denotation of a fixed type to a node? we will argue that the answer to these questions is less clear-cut than amr's general framing as a "simplified, standard neo-davidsonian semantics" (banarescu et al., 2019) or existing translations into logic might suggest. there is a potential difficulty which might prevent us from systematically thinking of amr nodes as objects, events or states. amr merges two distinct terms of classical logic into a single node (or rather, a single attachment point): predicate and variable symbols. the logical counterpart to a node labeled 'cat' involves intuitively a formula like cat(x), combining a predicate symbol cat and a variable x. by merging, we do not mean that amr does not display these two components separately (in fact, it does, since the entity arguably corresponds to the node itself, and the predicate to its label). @xcite what we mean, is that amr merges the possibilities to further refer to the predicate, or the variable. in other words, a node features only one attachment point for two distinct components of meaning. @xcite the situation is different in, say, church's theory of simple types (commonly used in semantics, in conjunction with the neo-davidsonian approach), where a term like cat(x) results from the combination of two different terms in the lexicon, which nothing refrains from occurring separately as arguments of other terms. one is of type ⟨e,t⟩ (λ x cat(x), generally modeled as originating from the noun), and one of type e (x, generally modeled as originating from the determiner, jointly with a binding quantifier). we will assess whether this difference challenges a denotational semantics for amr. we will base our investigation on two types of evidence: the logical translation proposed by lai et al. (2020) and intuitions based on annotated sentences in amr corpora and guidelines (knight et al., 2021; banarescu et al., 2019). ## graph nodes as entities as mentioned above, amr claims to implement a simplified neo-davidsonian semantics, which naturally suggests interpreting nodes as individuals or eventualities: "we do not point to an element in an amr and say 'that is a noun' or 'that is a verb'. rather, we say 'that is an object' or 'that is an event"' (banarescu et al., 2019). bos (2016) and lai et al. (2020) formalize the connection with systematic translations from amr into symbolic logic. we will take the latter (which in many ways constitutes a refinement of the former) as a starting point to examine the denotation of amr elements. by definition, a compositional semantics for amr needs syntactic composition rules to operate. since the treatment of universal quantification or negation has no incidence on our discussion, we restrict ourselves to what bos (2016) calls "basic" amrs, the syntax of which is described by the bnf grammar below. non-terminals are in bold sans. x, c, p and r are meta-variables. x ranges over variable they claim to be equivalent to the graph. symbols {x,y,...}, c over constant sequences {"m. krupps", "obama",...}, p over node labels {like-01, girl, ...}, and r over (non-inverse) roles {arg0, arg1, domain, ...}. r -1 describes the inverse of role r (arg0 -1 = arg0-of, domain -1 = mod, . . . ). finally, ε denotes the empty sequence. both bos (2016) and lai et al. (2020) syntactically distinguish "projective" and "assertive" nodes to provide a sound treatment of reentrance. we simplify this by systematically interpreting arguments to an inverse role as assertive and arguments to a standard role as projective without additional syntax. @xcite lai et al. (2020) provide a continuation-style compositional semantics for amr. the semantic composition rules are given below. figure 4 illustrates the syntax of the amr of figure 2 (there is a girl who likes herself ). figure 3 shows how the semantics of this example unpacks. the above rules interpret amr as trees rather than graphs. two amrs differing only by their root will generally receive distinct denotations. for instance the amrs from figures 1 and 2 contribute equivalent propositions, but they would pass on different entities as argument to incoming roles (respectively, the girl and the liking). this also means that graph nodes have a dual denotation, because they generally assume two different forms in the corresponding tree. for each node x in the graph, the tree must contain exactly once an instance description x/p, and it can additionally contain an arbitrary number of additional references to x as a standalone variable (as many times as the node is argument to a re-entrant role). while both cases have distinct denotations, these denotations are all of the same type, namely that of a generalized quantifier ⟨⟨e,t⟩,t⟩. @xcite we can thus safely say that a node denotes a set of properties. while this obviously differs from denoting objects or events, it comes very close given that logical representations bear the extra burden of explicitly binding entities to some quantifier and domain of restriction. in the above translation, this binding is built into the denotation of the instance description x/p, which is why x/p does not denote an entity. in contrast, any other reference to the node as a variable x denotes λ f f (x), which is exactly the standard lifting of an entity x to the type ⟨⟨e,t⟩,t⟩. hence, nodes are seen as plain entity when used as argument to re-entrant roles. in the same order of ideas, note that amr does not express any distinction between indefinite and definite entities. thus the amr in figure 2 is also associated with the phrase "it's the girl who likes herself". to make this reading available, one could for instance non-deterministically switch to a rule like x/@xmath0, which, again, makes (x/p) denote a type-lifted entity. @xcite bos (2016) and lai et al. (2020) thus clarify the relationship between amr nodes and entities. their translations show that, while labeled nodes systematically introduce three distinct components of meaning from a logical perspective (a variable entity, a predicate restricting the domain of this entity, and a binding quantifier), nodes can be thought of as entities, in the sense that the amr roles linking nodes to one another logically express relations between entities. ## copula sentences some copula sentences represent a challenge for the view developed in the previous section. amr guidelines (section main verb "be"), state that copula sentences are represented using the :domain role most of the time. they associate the sentence the man is a lawyer with the amr below: applying the translation from section 2 yields the following term: one of the motivations for relating amr to logic is to model entailment. @xcite another is to specify the denotation of amr elements. however, as it stands, φ fails at both of these tasks. to see why, consider the sentence a lawyer sings, which is entailed by the man who sings is a lawyer, and its amr: the latter logically translates as: in order to discuss actual propositions rather than sets of continuations, let us define cls(γ) as γ(λ n⊺) (the closure of γ under a continuation trivially true of anything). the problem is that cls(ψ) is not entailed by cls(φ ), because lawyer(m) is not entailed by lawyer(l) ∧ domain(l, m). hence, we fail to capture even simple entailments. comparing φ and ψ also leaves us unsure about the denotation of l (and, consequently, lawyer) in these examples. does it denote a person in both, or a person in the first and a state/property in the second? importantly, we are not trying to decide whether copula constructions (or other kinds of predications) systematically introduce states (on this matter, see for instance asher, 1993; maienborn, 2005), only whether we can interpret an element like (l/lawyer) consistently accross different amrs assuming either option. if lai et al. (2020)'s semantics is to achieve this, then we should be able to explain the link between φ and ψ without making distinct assumptions about the domain of quantification for l, or the denotation of lawyer in interpreting one or the other. one way to satisfy this requirement, and solve the entailment issue, is to assume that l denotes a person in both amrs and interpret the :domain as equating two entities. this makes lawyer(l) ∧ domain(l, m) equivalent to lawyer(l) ∧ @xmath1. unfortunately, this solution is inconsistent with cases of copula constructions with adjectives, because the latter are also handled with :domain. let us illustrate this with another sentence from the guidelines: the marble is small. the annotated amr is (s/small :domain (m/marble)). if :domain expresses equality of entities, then the logical translation (after closure) of this amr is equivalent to: ∃mmarble(m) ∧ ∃ssmall(s) ∧ @xmath2: the @xmath3. this analysis seems dubious. if the sentence hid quantification over the domain of the adjective, one should expect semantic ambiguities, which are not observed for adjective copula constructions. for instance, lila believes that the marble is small does not have the de re reading there is a small thing which lila believes to @xmath4. but crucially, we can also reject it from more amr-centered considerations. for instance, the amr for the marble is very small is: interpreting :domain as equality between entities in the latter is nonsensical, since it would let very modify an object, and would therefore amount to reading the sentence as the @xmath5. we thus reject an interpretation of :domain as equality on the basis that its two arguments are generally of incompatible types. in the example above, (m/marble) denotes an object, but (s/small) must denote something of a more abstract nature, which supports degree modification. potential candidates for the denotation of (s/small) are the property of being small, or a neo-davidsonian entity representing a "state" of having this property. this is backed up by cases of copula sentences which are not handled with :domain in amr. we provide two examples below, respectively taken from the guidelines and proxy files of the amr corpus (knight et al., 2021), and suitably truncated for the sake of space ([...] indicates truncated roles): amr 4: the boy is a hard worker (isi_0001.25) there is arguably no reason to think that these two sentences would relate different types of objects from the ":domain" kind of copula sentences above. amr 4 relates a person to a work that he performs, and amr 5 relates a person to an institutional position that he occupies. @xcite in both cases, a concrete object is related to a more abstract object akin to a property that the former can have, or a state that it can be in. we take this as evidence that :domain should behave similarly and relate an entity to some property or state. if these conclusions are correct, then lai et al. (2020)'s proposal cannot consistently handle amr representations of copula constructions like amr 2, because they switch the denotation of an element like (l/lawyer) to a type of object (a property or a state) different from their "standard" denotation in other amrs like amr 3. we will now show how to amend the compositional interpretation rules to resolve this inconsistency. @xcite we think that the focus on p2 is an annotation mistake and should rather be on h, but this does not change our point. ## default entity decomposition in the previous section, we have discussed a problem with the denotation of (l/lawyer) in sentences with the noun lawyer. this problem only generalizes to nouns giving rise to :domain edges in copula constructions. it does not occur with nouns that invoke propbank frames, such as worker, or amr role frames such as president. consider the two amrs below: amr 6: the man who sings is a worker the (closure) of their logical interpretation is given below, respective of the order: assuming ⊧ ∀x man(x) → person(x) as a meaning postulate, we predict the entailment from amr 6 to amr 7 without further difficulties. surely, the difference between worker and lawyer does not stem from a difference between :arg0 and :domain. rather, it stems from a difference of focus (in the amr sense). in the worker case, the focus of amr 6 ((w/work-01)) is not an instance of the same concept as the focus of the arg0 role of (s/sing-01) in amr 7. in contrast, in the lawyer case, the focus of amr 2 and the focus of the arg0 role of (s/sing-01) in amr 3 are instances of the same concept. the ability of the word worker to invoke two concepts, a person and a "working", solves the issue because both concepts can claim the focus depending on the use of worker in a sentence. in its "standard" use, the focus is on the person, but when used as object of a copula, the focus switches to the "working". this is not possible for lawyer basically because there is no propbank frame corresponding to the activity of "lawing", simply because there is no such word in english. in order to offer a consistent treatment for all copula sentences, we should therefore try to unify the treatment of "lucky" words which decompose along some propbank frame, and "unlucky" ones which do not. an appealing idea to this effect is to provide a default decomposition for every node, e.g., consider (x/p) as syntactic sugar for (x/e :mod (xp/p)), where e is a vacuous "entity" predicate. however, two obstacles are in the way: 1) without further restrictions, node decomposition would yield infinite amrs through recursive rewriting. for instance (x/p) would be understood as syntactic sugar for (x/e :mod (xp/p)), which itself would rewrite as (x/e :mod (xp/e :mod (xp p /p))) and so forth and so on. essentially, the solution to both problems is to forbid decomposing the origin of a :domain role (or the target of a :mod role), in order to implement the focus-switching mechanism described above. the idea is to let 'normal' nodes decompose into an amr (x/e :mod (xp/p)) focusing the fresh entity node, while leaving nodes with a domain role unaltered and thus keep focus on the original node in the latter case. we let τ denote the resulting "default decomposition" transformation. τ decomposes every node of an amr tree into an entity modified by a predicate, except when it has a :domain role. it is informally schematized below: for instance, in amr 2 both (m/man) and (s/sing -01) receive a default decomposition into an entity (m for man, s for sing-01) and a state (m p for being a man, s p for being a singing), but (l/lawyer) does not, because it has a domain edge. the result is the amr below: in fact, altering the original amr is not even necessary, since we can directly implement the default decomposition into the denotational semantics. to this extent, let us assume that v @xmath6,y p ,...} is a set of variable symbols disjoint from the one used in amr trees, such that each amr variable x can be injectively mapped to a variable x p in v p . we introduce a second interpretation function ⋅ d which is triggered for nodes with an outgoing :domain edge. in all of the following, r ranges over all roles except domain and mod. we abbreviate domain as dom. the "standard" interpretation rules are: figure 5 shows how the semantics unpacks for amr 2. one easily verifies that the result entails amr 3: the latter interprets as ∃l∃l p lawyer(l p ) ∧ dom(l p ,l) ∧ ∃s∃s p sing-01(s p ) ∧ dom(s p ,s) ∧ arg0(s, l) (since 3 does not have any :domain role, each of its nodes is decomposed). to check the entailment, notice that, up to renaming of the quantified variable l to m, every conjunct in the formula above also appears as a conjuct of the interpretation of amr 2 in figure 5 . to conclude this section, let us discuss some of the properties, benefits and limitations of the proposed default entity decomposition approach. while the target logical interpretations are undoubtedly less readable, they are obtained from the (unaltered) original amr. so what we have achieved is an improved notion of entailment between amrs, figure 5 : interpretation of amr 2 with default entity decomposition and a better understanding on the denotation of amr nodes in copula sentences, at no cost for the annotation capabilities of the formalism. the attentive reader might have noticed that nodes with a :domain role have an interpretation of type ⟨e,⟨e,t⟩,t⟩ differing from "regular" nodes whose interpretation is of type ⟨⟨e,t⟩,t⟩. while the additional entity-type argument might seem vacuous at first, it is in fact essential to handle (rather frequent) cases of nominal copula constructions where the noun following the copula is itself modified. consider, as an exemple, the following sentence from the amr corpus: teikovo is a small town in the ivanovo region about 250 kilometers or 155 miles northeast of moscow. the full amr is given in annex. for our present purpose, we only need to consider the following partial amr: ( t /town :mod (s/small) :domain (c2/city) ). our semantics, ensures that in this context the subtree ( t /town :mod (s/small)) denotes the complex property of being a town which is small, and that, as a result, teikovo (the city) is attributed both properties of being a town and being small. importantly, the property of being small is not attributed to the predicate town, but to the same entity that the latter ends up attributed to, whichever it might be. put another way, our semantics implements an intersective treatment of chains of modifiers. hence, (c/cat :mod (r/grey :mod (f/ fierce ) ) ) denotes a cat which is both grey and fierce. of course, adjectival modification is not always intersective, and roles such as degree or time will require a separate treatment. however, the intersective semantics appears necessary to reconciliate some observed variations in annotations, as displayed by the examples below. the revised interpretation can help us assess some difficult annotation choices. consider the two sentences only if ron paul doesn't become president then there will be war and and, that is something needed to become president. both sentences are from the amr corpus, and their amrs are provided in annex. annotators have made different choices for these two sentences: the first involves (b/become-01 :arg2 (p2/president)) whereas the second involves (b/become-01 :arg2 (p2/person :arg1-of (h/have-org-role-91 :arg2 (p3/president)))). are these two treatments of become president equivalent or incompatible? we can answer this question, at least if we admit that becomes is akin to a kind of copula construction foot_8 and that have-org-role-91 is also akin to :domain in that respect; it is the (reified) relation used to express e.g., ron paul is president. foot_9 under these assumptions, the question amounts to spotting the difference (if any) between (p/president :domain (r/ron_paul)) and (x/person :mod (p/president) :domain (r/ron_paul)) (ignoring amr decomposition of named entity, for simplicity). our semantics associates the former with the proposition ∃r∃r p ron_paul(r p ) ∧ dom(r p ,r) ∧ ∃p p president(p p ) ∧ dom(p p ,r) and the latter with the proposition ∃r ∃r p ron_paul(r p ) ∧ dom(r p ,r) ∧ ∃x p person(x p ) ∧ ∃p p president(p p ) ∧ dom(p p ,r) ∧ dom(x p ,r). if a president must always be a person, then the two are clearly logically equivalent. the approach, however, yields arguably puzzling scoping when e.g. attitude verbs have copula sentences as objects. while the two amrs discussed in the previous paragraph have equivalent closures, their different focus yield different propositions when embedded. consider, under the same modeling hypotheses, the sentence i believe that ron paul is president. the amr ## quasi-predicates we now turn to a different problem, which originates from the same discrepancy between the words of english which invoke propbank frames, and those which do not. the phenomenon at stake is the treatment of what meaning-text theory (mtt) calls quasipredicates. mel'čuk and polguère (2008); polguère (2012) define predicates as those lexical meanings that have two properties: 1) they denote situations (in a broad sense including events and facts), and 2) they involve a number of semantic participants whose value is contingent, but whose participation is necessary. polguère notes that predicate are commonly put in opposition to semantic names, like the meanings 'rock' or 'star'. semantic names denote entities rather than situations and they can be defined without reference to participants. yet, polguère observes that there is a vast class of meanings, like those of brother, consumer or therapist which denote entities (like semantic names), but cannot denote without accounting for a certain number of participants, due to the presence of a predicate with unbound arguments in their semantic decomposition. these meanings are called quasi-predicates (henceforth, qp). in essence, a qp can be assimilated to a pair made of an entity and a defining predicate, with focus generally put on the entity (though polguère (2012) remarks that this is challenged in some constructions, typically copula). for instance, the meaning of brother is an entity x (a man), combined with a predicate (x having a common parent with y ). sometimes, the structure of a qp is displayed explicitly in amr, i.e., the entity and the defining predicate give rise to different nodes. consider for instance the example below: in this case, the entity client itself is linked to the other participant, there is no separation between entity and defining predicate. while in and of itself these differences are not a problem, they have no other basis than the peculiarities of the english lexicon. the verb to client does not exist, and consequently, there is no propbank frame to decompose the meaning of client. the asymmetry between client and brother is therefore the same as noted in the previous section between worker and lawyer. what is new however, is that amr suffers expressive limitations when representing qps because of this. for instance, we cannot represent the meaning of the therapist thanks his client in a way that makes explicit both the fact that the client is the client of the therapist, and that the therapist is the therapist of the client, for we would end up with the cyclic amr below. interestingly however, reifying (banarescu et al., 2019) :poss with own-01 removes the cycle: amr 10: reified :poss reification is introduced in amr as a mechanism needed to focus a role. but in this case, it is not what it achieves. rather, reification "borrows" the frame own-01 and uses it as a default to decompose therapist and client. indeed, the problem disappears for words which invoke propbank frames, for instance the seller thanks the buyer has an amr isomorphic to amr 10. the default decomposition approach from previous section generalizes this solution, by systematically providing an additional abstract attachment point (the predicate) for any outgoing role of the defining predicate of a qp: amr 11: default decomposition importantly, the approach allows to handle any kind of qp, even if the relationship to their participants is not expressible as a reifiable non-core role like :poss. ## conclusion whereas seeing amr nodes as davidsonian entities seems overall very sound from a logical perspective, we have shown that copula sentences pose an important challenge to this view. the challenge arises because they require to isolate the predicative part of a node from the entity it denotes. we have proposed a unifying mechanism of default decomposition, which systematically entangles the two notions. we have implemented it in a denotational semantics for amr which does not require any addition to the original amr annotation. we have shown that this approach generally resolves linguistically unjustified asymmetries depending on the existence of propbank frames, in particular regarding the representation of quasi-predicates.