QUE feature on the verb

I am finding myself confused suddenly about what should happen with the QUE feature, generally, in the context of wh-questions.

I have a basic implementation in my version of the Grammar Matrix which is based on LING567, and that one uses non-empty QUE lists for lexical entries for wh-words and then the phrase structure rules, such as the Head Filler, may expect that the non-head daughter has a non-empty QUE, for example.

As for the verb, it currently has an empty QUE list.

In a recent meeting, I think it was mentioned that the verb is actually supposed to collect stuff on its QUE list? According to what though? I am not seeing anything like this in the ERG, although it is not easy to refer to the ERG because of its complexity and a large number of differences in features (differences with the Matrix).

In Ginzburg and Sag, they use STORE and WH features (and QUE actually isn’t mentioned; I think they don’t use it at all), and the verb’s STORE will indeed have multiple things on it.

Does it sound like I should be comparing STORE with QUE?.. As for WH, verbs do not collect things on their WH feature; that one in fact used more like QUE in the Matrix currently (lexical entry and then filler gap).

Update: Found a footnote confirming that WH is used similar to QUE as in P&S.

So, the question becomes: should I worry about verbs’ own QUE at all?

My understanding of the original purpose of QUE is that it’s meant to handle pied-piping (Which cat did you see?). It may also have played a role in the ERG for detecting suitable fillers in wh-question subtypes of the head-filler rule, as it does in the Matrix instructions. I also use it there (I think) to track the presence of wh-in-situ…

All of which suggests no “lexical threading” of QUE values. What in fact is already there in matrix.tdl? Is QUE treated similarly to SLASH in the basic-one-arg type and its ilk?

I think so. So, what I seem to remember happening in the meeting is not a thing, then?

(As for Ginzburg and Sag’s STORE, that I think is their realization of RESTR?)

Here’s what a sentence with multiple question words looks like in the ERG:

(1) Who saw what?

what will have a non-empty QUE; so will saw what, the VP. Then there is the subject extraction rule, and at that point, the non-empty QUE value disappears. (So, the subject extraction rule does that.) Then the head filler rule takes who, which also has a non-empty QUE value, as its non-head daughter and the S/NP which now has an empty QUE list, as its head daughter.

[[ UPDATE: The above description of what the ERG does is wrong; there are in fact two trees for Who saw what?. In one, what is a CP and is QUE-empty. In the other, what is a noun and is QUE-nonempty, and that QUE value travels up to the mother of the subject extraction (just like what I do in the Grammar Matrix). ]]

In my current implementation, the non-empty QUE percolates up to the top S (because I allow head-filler to take a non-empty-QUE head daughter) where it is “forgotten about” because the mother of the head filler rule is a subtype of clause.

This is all somewhat different from G&S (they use WH for QUE) who only use non-empty WH in filler daughters. In-situ wh-words are WH/QUE-empty, and so they have more than one lexical entry for each wh-word. But their in-situ analysis is not the same as I would need for the Matrix; it is for reprise questions in English and such. For in-situ as a way of forming a typical question, they seem to be suggesting non-empty WH/QUE for the in-situ wh-words, and I don’t think they touch on multiple questions there…

I am not yet sure what I am asking here; just laying the facts out, I guess.

I guess, the question is: theoretically, where should the “extra” QUE values go, at the end of the day?

I’m afraid I don’t have answers here, but hopefully the following at least can be helpful:

(1) Yes, I suggested in that meeting that the verb should “gather up” the QUE values of its dependents. (This may have been incorrect.) If it is doing that, the constraints would be on types like basic-two-arg. What do you see there?

(2) The purpose of QUE is to track the presence of wh words and make sure they’re sufficiently accounted for. It may not be tenable to use it for both pied-piping and wh in-situ the way I suggest in the 567 instructions.

(1) OK, I see! basic-two-arg does gather up the QUE values like the SLASH values. I am not seeing the effect of that in my grammars though (broken append or not inheriting from the right type somewhere?)

I am also not seeing the effect of that in the ERG though (fwiw). Again, ERG structures are not as easy to look at as Matrix structures, but I am pretty sure that, when I look at saw in who saw what, its QUE is empty.

This see is a v_cp_fin-inf-q_le which is this:

v_cp_fin-inf-q_le := main_verb & 
Cmps S (fin/inf, +Q)             
<ex>B wonders whether to jump.
  [ SYNSEM cp_ques_fin_inf_intrans_verb ].

So, a special verb type for questions.

Regardless, ultimately it is a basic-two-arg, so I am confused about why I am not seeing non-empty QUE on the verb itself.

For a Matrix-based grammars – the info could be getting lost because some phrase structure rule doesn’t copy it up or because one of the arguments to the append is underconstrained.

For the ERG: does ERG’s basic-two-arg do the same thing with QUE? But: that verb type definitely isn’t the one in who saw what unless what is being analyzed as a CP.



There is two trees, in one of them what is indeed an CP. The CP is QUE-empty, hence the empty QUE on the verb! In the other, it is a noun, and it is a different lexical entry for see, and there I do finally see a non-empty QUE on the verb! (Of course I now cannot find at what point it inherits from basic-two-arg but I am sure it does).

…So my task is now to fix QUEs on my verbs, looking for a broken append or an underconstrained lexical type.

Yep, my verbs were not inheriting from basic-two-arg (in the Russian grammar, not in matrix grammars) due to a change that I had made long time ago (without realizing that I am breaking this part of the analysis).

…Nope, not that.

Each type of transitivity inherits from the appropriate supertype, e.g. intran-verb-lex from intransitive-lex-item. Those inherit from the appropriate basic-X-arg supertypes…

I was going to say – you’d have to go pretty deep to bypass these types.

So I think the verb type is OK. I traced it up to basic-two-arg. It is tran-verb-lex – nom-acc-transitive-verb-lex – transitive-verb-lex – transitive-lex-item – basic-two-arg-no-hcons – basic-two-arg.

So it must be a broken append somewhere. Was there a way to identify the place where it gets broken? I am looking at both local and full AVMs for the verb (the leaf node) and its QUE is empty either way. The who has a non-empty QUE as expected…

This is *Who sees a dream?" below.

…The above is full AVM; here’s local:


The lists should look different, right? In terms of their LAST values.

The strategy here is to find the lowest constituents with “unhealthy” QUE values — that will likely be the verb and one of its arguments. “Unhealthy” means that the LAST doesn’t point to anything.

As for the example sentence – please always include IGT. I can’t guess which of those words is “who” :slight_smile:

Sorry :).

(1)  Кто     видит сон?
     Kto     vidit son?
     who.NOM sees  a.dream.ACC
`Who sees a dream?' [rus]

Alright, so it appears that the lists are broken at the very bottom, then. That puzzles me again because the verb does appear to inherit from basic-two-arg. What else can be involved, apart from its actual lexical type?

And what is the difference between “full” and “local”, again?

(1) The problem would be with ‘who’ or the other noun (or the lexical rules). The verb is trying to append diff-lists; if one of them is underspecified, then the whole thing is broken. (This is part of why I think Emerson lists might be easier to work with!)

(2) “full” includes information unified in from the broader context, in my experience is almost never useful, and is particularly confusing in this kind of case. Use “local”.

No objections here; I just haven’t gotten to that yet.

(Continuing to debug this…)

My wh-pronoun wasn’t in fact inheriting from basic-one-arg so I fixed that, however that did not have any effect on this.

Currently, the wh-pronoun looks fine to me:


I am seeing something strange on the common noun (the object of the verb):

It’s SLASH is non-empty for some reason, and what’s even more surprising, the type of the list says 0-dlist? The non-emtpy part: could that be because of the optional specifier? In that case it is expected. The 0-dlist part I don’t know how to explain at all.

Otherwise, common nouns definitely inherit from basic-one-arg.

Lexical rules, then? Is there a particular type most of them should inherit, that I could check?

Hold on, I think I’ve been looking at “full” again instead of local.

If I make sure I look at local for the common noun, here’s what I see for its NON-LOCAL features:


This is underspecified, yes?