Debugging a lost slash constraint

I seem to have lost a constraint somewhere and I can’t immediately figure out what happened. Is there any systematic way of debugging these?

Here’s what is happening in the picture below. The top S is licensed by the wh-question phrase which is fine. However, the wh-rule requires a slashed head daughter, and in this case, there should not be one because no extraction rule has applied (a separate question is why the extraction rule hasn’t applied). If no extraction rule has applied, then there should be nothing on this S’s slash list, and so the wh-rule should not apply. I must have lost something pretty deep on the clause-level constraints. For some reason the grammar is happy to just assign the non-empty slash value to the S. I have looked at the relevant types (Head-Comp rule, Head-Subj rule, wh-rule, and their supertypes) but cannot yet spot what is it that I removed…

Posting in the hopes that someone just knows which type should be responsible for keeping track of the slash values here…

42%20AM

It seems that the SLASH value is copied from the head daughter to the mother by the type called head-valence-phrase. I haven’t touched that type, and my head-subject rule inherits from it. In the local AVM for the head-daugher S (the cat sees what), the slash list appears empty.

Why then does the wh-rule fire here?..

This is symptomatic of an underspecified diff-list value somewhere which breaks the diff-list append. The trick to debugging these is to look for the lowest constituent in the tree that has the problem and then look within it for the element that is leaving its SLASH value underspecified. Pay attention to the lexical amalgamation stuff: the basic-*-arg types build this in. Perhaps you have something that’s not inheriting from one of those?

1 Like

Right…

So, I look at the AVM (not the local AVM though) for what (the NP), and it has a non-empty slash list. Would we call that the lowest problematic thing then? (Except it isn’t a true constituent, it is a subterminal…)

You definitely want to look at the local AVM–selecting AVM will give you unified in constraints which are confusing as all get out in this case.

Right. In that case, the first node where things look wrong is actually the top one… The local AVM for the cat sees what has an empty slash list. Does this mean the problem must be in the wh-question phrase itself, or not necessarily?

Really empty, or just underspecified? An “unhealthy” SLASH list doesn’t have the LAST identified with anything on the LIST.

1 Like

Aha! Indeed, here’s what I have on the the cat sees what S:

25%20PM

So, the real empty SLASH should look like REL, then.

Trying to track it down, the VP sees what looks like this:

15%20PM

Are both SLASH and REL healthy or unhealthy here? And QUE, for that matter?They identify their LAST with something but there is no connection to the LIST?

And then finally, should I only be checking this on the constituent and not lextype level?

All three of SLASH, QUE and REL look unhealthy there — I’m guessing that you didn’t constrain these appropriately on the lexical type for what, which in turn is breaking the diff-list append with see.

Eventually, yes, you want to go look at lexical types in the tdl. But the methods for finding the culprit starts with the trees…

Alright. And on the Head-Subj-licensed node, REL and QUE look fine, yes?

Aha. The basic-one-arg supertype was missing from my definition of the wh-word! Unfortunately, adding it did not help. Here’s what it looks like now:

wh-word-lex := norm-hook-lex-item & basic-icons-lex-item & basic-one-arg & 
  [ SYNSEM [ LOCAL [ CAT.VAL [ SPR < >,
                               SUBJ < >,
                               COMPS < >,
                               SPEC < > ],
                     CONT [ RELS <! [ LBL #larg,
                                      ARG0 #arg0 ], [ PRED "which_q_rel",
                                                      ARG0 #arg0,
                                                      RSTR #harg ] !>,
                            HCONS <! [ HARG #harg,
                                       LARG #larg ] !> ] ],
             NON-LOCAL.QUE <! #arg0 !> ] ].

wh-pronoun-noun-lex := wh-word-lex & non-mod-lex-item &
  [ SYNSEM.LOCAL [ CAT.HEAD noun,
                   CONT.RELS <! [ ARG0 ref-ind ], [ ] !> ] ].

Who should be saying something about this item’s SLASH list? basic-one-arg links it to the ARGS. What is missing?

Why would wh-word-lex be basic-one-arg? That type is for words with an ARG-ST of length one. I think you want something like basic-zero-arg, but not quite, because the QUE value there is wrong… so probably just borrow the SLASH and REL constraints from basic-zero-arg.

Hmm, my noun-lex is basic-one-arg, and that comes from the GM, I am fairly sure. What’s on the noun’s ARG-ST?

But basic-zero-arg looks like this:

basic-zero-arg := lex-item &
[ ARG-ST < > ].

– and there doesn’t seem to be anything useful in the lex-item…

Aha!

This seems to have done the right thing:

             NON-LOCAL [ QUE <! #arg0 !>, 
			 SLASH 0-1-dlist & [ LIST #list, LAST #list ], 
			 REL 0-1-dlist & [ LIST #list, LAST #list ] ] ] ].
  • the last two lines were not there. (They aren’t on the basic-zero-arg either though; should they be?)

Oh, I see – the existing type that you want is zero-arg-que := zero-arg-nonslash & zero-arg-nonrel.

Nouns have a non-empty ARG-ST because they take a SPR (and amalgamate non-local features from it, crucially in this case QUE for pied-piping).

1 Like

Oh right!! I don’t need 0-1-dlists here; that’s (possibly) for the phrase structure rules which allow more than one question. But not for the wh-words themselves; why would they need a non-emtpy slash list. I think this issue is now resolved, thank you so much :).