Variables and Variable Types

I’m trying to understand variables in the ERG and I apologize in advance for the long post. Let me start by stating what I think I know so far to make sure it is right:

Instances and Eventualities

In my mind I’ve divided the world of “terms” produced by an MRS EP in the ERG into two groups: quantifiers and predicates. “Quantifiers” have an (ARG0, RSTR, BODY) signature. Everything else I’m calling a “predicate” and will at least have an ARG0 but possibly other arguments.

I think I have my head around two types of variables:

  • Instance variables (x) are always declared and bound by exactly one quantifier and can only be used by other terms in its scope
    • They appear to always be referring to what I’ll call the “real world” (as opposed to the structure of the sentence, see next type…).
    • After declaration, exactly one predicate can use this quantifier as its ARG0, but many other predicates can use it in other positions.
  • Eventuality variables (e) appear to be declared and bound implicitly so they are visible to all terms, but are “introduced” or “owned” by exactly one predicate that has it in its ARG0 position. They appear to be used in at least two ways:
    • To declare an “event” that is introduced by a verb and is something that conceptually (if you twist your mind a bit) exists in the world
    • And also in a “meta” way, meaning that their purpose is modify the meaning of the words themselves (as opposed to modifying a “real world” thing) by allowing different terms to form relationships: like when you need to say “very” is modifying “slimy”

Every predicate has to uniquely “introduce” some kind of variable in ARG0, even if it isn’t used.

For example:

"a very slimy cave"
    and(_very_x_deg(e9, e10), _slimy_a_1(e10, x4), _cave_n_1(x4)), 
    unknown(e2, x4))
  • “_a_q(x4,…,…)” declares we are going to be talking about something in the world, eventually contained in “x4”, by declaring and binding that variable and then using the second argument to filter it down to what we are talking about.
  • _cave_n_1(x4): tells us that we should filter x4 to be something that is a cave.
  • _slimy_a_1(e10, x4): tells us to make sure the things in x4 are also slimy. And: since slimy can (potentially) be modified by (for example) degree of slimyness, it introduces an eventuality e10 for other terms to (optionally) attach to.
  • _very_x_deg(e9, e10): Indeed does attach to slimy via e10, and introduces yet another eventuality because it might be modified too. Turns out it isn’t in this example.

Question 1: Am I on the right track so far?

Other Variable Types

As listed in erg.smi, there are a few other variable types in a hierarchy:

i < u.
p < u.
h < p.
e < i : SF sf, TENSE tense, MOOD mood, PROG bool, PERF bool.
x < i & p : PERS person, NUM number, GEND gender, IND bool, PT pt.

I found a one word description of the types of variables here:

event      <> e
ref-ind    <> x
individual <> i
handle     <> h
non_event  <> p
* >> u
semarg << u

Question 2: Is there a good conceptual description of those types somewhere?

1 Like

Have a look here:

You may also find everything linked from this page useful as you work to understand MRS:

1 Like

thanks @ebender. I’ve read through those pages 100 times for other things but somehow didn’t reread the “basics” one again once I finally got more of a handle on eventualities. Every time I come back to it after reading some background, article or book, more of it makes sense.

Ignoring the bits about “real world”, as we often do, and speaking only to the structural description, I’ll add a few points (maybe more than you’re asking for):

  • We didn’t use to give everything (except quantifiers) an intrinsic argument (ARG0), but now it is assumed for a well-formed structure; they serve as imperfect identifiers of EPs
  • The intrinsic variable property (IVP; see below) essentially states this requirement and it is (mostly) necessary for conversion to dependencies (DMRS or EDS)
  • But not all grammars (maybe not even the ERG) have been fully updated to conform to the IVP
  • All x variables are supposed to have a quantifier, but you may find some (even in the ERG) that don’t; these are generally considered grammar bugs, but there are discussions of relaxing this for dropped arguments (see below)
  • Dependency representations (EDS and DMRS) do not need (or have) variables because nodes (formerly EPs) have unique identifiers

Intrinsic Variable Property

Oepen and Lønning, 2006 explicitly assumed the presence of a distinguished variable for conversion of MRS to EDS dependencies, and Copestake, 2009 defined the similar characteristic variable property for converting to DMRS dependencies. The distinguished and characteristic variables are historical terms that refer to the same thing (ARG0s), and we later agreed to call them intrinsic variables. In any case, the general idea is that each EP gets an ARG0. Somewhere I’ve described the differences in how Copestake, 2009 defined the (rebranded) “intrinsic variable property” and how I evaluate it in PyDelphin, but I can’t turn up anything at this moment. Basically there are three conditions under discussion:

  1. All non-quantifier EPs have an ARG0
  2. All variables are the ARG0 of some EP
  3. The ARG0 of an EP is unique to it (not the ARG0 of any other EP)

Copestake, 2009 defines the IVP as (3), which, in her description, implies (2). She further assumes (1) for the purposes of the paper. PyDelphin defines the IVP as (1) and (3). It does not require (2) because of observed (and presumed good) MRSs that do not follow (2), but this depends on what a “variable” is. Handles (h), for instance, are generally not considered variables, despite h being in the variable hierarchy. It’s less clear if underspecified variables i, p, and u fall under (2), and they (particularly i) appear in a few contexts (dropped arguments, scopal modifiers, and true underspecification where it’s not decidable or decided if an EP represents an instance or eventuality); for these see below.

Dropped arguments, etc.

A convention in MRS is that when an argument is dropped (e.g., I left. vs I left Oregon.) there is no EP introduced for the missing argument and its variable becomes underspecified (an i instead of an x). This is, I guess, to avoid requiring a quantifier for the variable. However i variables are also used for some scopal modifiers (e.g., for _never_a_1 in I never left.) and things like compositional numbers (for the EPs for “20” and “8” in Kim drove for 28 hours). I brought up this issue at our last research summit in Cambridge (see Section 3 of my presentation notes and the minutes of the discussion). There were some proposals for resolving the various meanings of i variables in MRSs but I think the current situation still stands.

Other links

You might find some more information in these places:

  • PyDelphin’s documentation of the delphin.variable module
  • Sections 2.5 and 2.6 of my dissertation (I don’t think it has any new information not already discussed but you might find other parts of that chapter informative).

I don’t think you could give me too much detail at this point @goodmami, thanks!

The chapters of your dissertation was a great overview and filled in some gaps on the other representations that I had been ignoring and I didn’t notice the detail on variable types on pydelpin which I’ll bookmark too.

The pointers to places where I can expect “i” variables will be great when I loop back to try to process them. For now, I’m trying to get a processing model for e and x variables, but wanted to understand what I had on the horizon to guide the approach. This background is very helpful!

@goodmami I think you’re referring to this discussion? New uses of underspecified variables in the ERG 2018?

That’s it! Thanks, @trimblet, for some reason I had forgotten to check this Discourse board.

That thread actually predates the discussion at the summit, but there’s good information from Woodley posted after the fact. Also, it now makes me realize we could posit another potential criterion for the IVP:

  1. All quantified variables are the ARG0 of some EP

I am not, however, saying whether (4) is something we should adopt, considering Woodley’s example in the other thread. But note that it is redundant if we accept (2) above as a criterion along with the general principle (also controversial?) that all x variables are quantified.

1 Like

For others stumbling on this thread in the future: I think I finally got my head around the topic and summarized my understanding of variables and variable types here after working with the ERG a bunch and getting lots of great data from this board and the documentation. Hopefully it can be another tool to get up to speed quickly.

There is a deeper drill down into events since it was much harder to get my head around them and how to evaluate them using a logic system like Prolog.