Constraining Head-Filler rules' head daughter's SLASH with append-lists

After I converted everything to append-lists and also got rid of specific append-list subtypes (like 0-1-alist), I ended up with head-filler rules which happily take as head daughters things which aren’t supposed to have nonempty SLASH lists.

I am trying to get rid of that but somehow this seems to have zero effect (see particularly the constraint on the HEAD-DTR of wh-ques-phrase; the rest are given for context):

experimental-basic-filler-phrase := binary-phrase & phrasal &
  [ SYNSEM [ LOCAL.CAT.VAL [ SPR < > ] ],
    ARGS < [ SYNSEM [ LOCAL local &
          [ COORD -, 
          CAT.VAL [ SUBJ olist,
          COMPS olist,
          SPR olist ],
            CTXT.ACTIVATED + ],
          NON-LOCAL.SLASH append-list ] ],
     [ SYNSEM [ LOCAL [ COORD -, CAT [ VAL.COMPS olist ] ],
          NON-LOCAL [ SLASH append-list,
          REL 0-alist ] ] ] > ].

experimental-1st-head-filler-phrase := experimental-basic-filler-phrase & head-compositional &
  [  SYNSEM.NON-LOCAL.SLASH.LIST #slash,
     ARGS < [ SYNSEM.LOCAL #local ],
	   [ SYNSEM.NON-LOCAL [ SLASH.LIST < #local . #slash >,
				                  REL 0-alist ] ] > ].

wh-ques-phrase :=  experimental-interrogative-clause & 
		  head-final &
   [ SYNSEM.LOCAL.CAT [ MC bool,
			VAL #val,
			HEAD verb & [ FORM finite ] ],
     HEAD-DTR.SYNSEM [ LOCAL.CAT [ MC na-or-+, VAL #val ],
                       NON-LOCAL.SLASH.LIST cons ],
     NON-HEAD-DTR.SYNSEM [  LOCAL.CAT.VAL [ SPR < >, COMPS < >, SUBJ < >],
                            NON-LOCAL.QUE.LIST < ref-ind > ] ].

wh-1st-ques-phrase := experimental-1st-head-filler-phrase & wh-ques-phrase.

Does anyone see what am I doing wrong or has an idea where else I should look?

At a guess (and without looking deeply into the tdl), I wonder if the problem is that the SLASH lists are underspecified because not all of the arguments have been picked up yet? Are you getting spurious parses, or just spurious edges?

[And that’s it from me until the new year … signing off now!]

1 Like

Just edges. Will continue looking into this!

If it’s just edges, I think it’s expected: At the VP level, for example, the SLASH value is still underspecified because the subject hasn’t been picked up. (This is because of lexical threading: the verb’s SLASH is the append of its arguments’ SLASHes, but we don’t know what the SUBJ’s slash is yet.)

1 Like

I see; perhaps in that case it was expected but in other cases, I am seeing also some unexpected parses, so I think the rules are still not constrained properly.

Here’s one situation:

(1) Chto     Ivan     komu    daet
    what.ACC Ivan.NOM who.DAT gives
`What is Ivan giving to whom?' [rus]

Screen Shot 2020-01-02 at 2.48.25 PM

Note the lowest binary subtree, the V spanning komu daet. That subtree is licensed by the following rules:

wh-2nd-ques-phrase := experimental-2nd-head-filler-phrase & wh-ques-phrase.

wh-ques-phrase :=  experimental-interrogative-clause & 
		  head-final &
   [ SYNSEM.LOCAL.CAT [ MC bool,
			VAL #val,
			HEAD verb & [ FORM finite ] ],
     HEAD-DTR.SYNSEM [ LOCAL.CAT [ MC na-or-+, VAL #val ],
                       NON-LOCAL.SLASH.LIST < [], ... > ],
     NON-HEAD-DTR.SYNSEM [  LOCAL.CAT.VAL [ SPR < >, COMPS < >, SUBJ < >],
                            NON-LOCAL.QUE.LIST < ref-ind > ] ].

experimental-2nd-head-filler-phrase := binary-phrase & phrasal & head-compositional &
  [ SYNSEM.NON-LOCAL.SLASH.LIST < #firstarg . #otherargs >,
    ARGS < [ SYNSEM.LOCAL #local ],
     [ SYNSEM.NON-LOCAL [ SLASH.LIST [ FIRST #firstarg, REST < #local . #otherargs > ],
          REL 0-alist ] ] > ].

So, what I don’t understand is, why is that the rule licenses the V subtree even though no extraction rule applied to the leaf V (the V->V is a lexical rule, 3SG)? The leaf V’s SLASH.LIST should be empty (it does inherit from the appropriate ditransitive-lex-item which in turn is a subtype of basic-three-arg-no-hcons). I think the wh-rule is saying that the head daughter’s SLASH.LIST must not be empty?.. Why then?..

That’s a bit puzzling, but I think you also want to get rid of that subtree by saying that the head-filler phrases require COMPS < > and SUBJ < > on the head daughter.

But then I wouldn’t be able to use it to do multiple extraction, would I? In other words, I would lose this tree along with the unwanted one:

Screen Shot 2020-01-06 at 2.11.40 PM

Here, first the 2nd complement (dative, komu is extracted and filled, then Subj-Head rule applies, then the subject is extracted and filled.

I think this is back to the same question of whether the dative complement here is in fact extracted (like in the other thread with the adjunct that’s between the subject and the verb).

If the subject is in the front, then I guess the complement that’s in between hasn’t been extracted. So I need an extra lexical entry for it? (Which would be in line with Ginzburg and Sag).

I’m fairly sure that you don’t want to use extraction unless the only thing to the left of the word is another wh word. Otherwise, your word order flexibility should do the work. The prediction here is that extraction can cross clause boundaries, but the other kinds of word order flexibility can’t.

1 Like

With additional, QUE-empty lexical types for wh-words, right? Otherwise there will be a different type of ambiguity, unless I constrain non-filler rules to have QUE-empty non-head-daughters?

In general, I think you need to allow for in situ wh words. You’ll need the QUE empty entries for these regardless. This particular sentence doesn’t add any complexity in that regard.

OK I think that’s the right thing to do, yes.

I am still confused about why I was having those trees despite the cons constraint on the head daughter’s SLASH. If I see more of that in the future, I will post here again…

OK, here’s another example of this (the head-filler rule producing a parse where no extraction rule has ever applied).

Here’s an ungrammatical sentence:

(1)  *Kogo    chto     Ivan     vidit?
      who.ACC what.ACC Ivan.NOM sees?
     Intended something like "Whom and what does Ivan see?" [rus]

Here’s the tree that I am getting:

Screen Shot 2020-01-08 at 12.02.16 PM

The top S is licensed by the head-filler rule; the lower S by comp-head rule. Both NPs are CASE accusative in the tree. No extraction rule applies at any point (the V->V is tense/pernum inflection on the verb).

The head-filler rule should be constraining its head daughter to have non-empty SLASH.LIST (as shown in the above posts). The verb is a subtype of basic-two-arg. Both NPs are subtypes of basic-one-arg.

Why?..

Umm, so, head-complement rules were not constraining their head daughters to be SLASH-empty… Why would I only notice that now? Also, seeing as this has been like that always, am I even on the right track?

The first things I would look at are:

(1) What is the SLASH value on each of the V edges / local avms?
(2) What is the SLASH value on the lower S edge / local avm?

Umm, so, head-complement rules were not constraining their head daughters to be SLASH-empty… Why would I only notice that now? Also, seeing as this has been like that always, am I even on the right track?

This is surely on purpose, given the lexical threading analysis: The SLASH value will be non-empty when e.g. the subj-extraction rule applies, even down below, because of lexical threading.

1 Like

the lowest V: append-list which I think does mean underspecified. I guess that’s the explanation, now if only I knew why it is underspecified… It is a subtype of basic-two-arg…

basic-two-arg := lex-item &
  [ ARG-ST < [ NON-LOCAL [ SLASH #s2,
                           REL #r2,
                           QUE #q2 ] ],
	     [ NON-LOCAL [ SLASH #s1,
			   REL #r1,
			   QUE #q1 ] ] >,
    SYNSEM.NON-LOCAL [ SLASH.APPEND < #s1, #s2 >,
                       REL.APPEND < #r1, #r2 >,
                       QUE.APPEND < #q1, #q2 > ] ].

Okay, that makes sense, because that V doesn’t know what its arguments are yet. So trace that value up the tree (local AVMs at each step). Where does it change?

It’s confusing to me… Here are screenshots. I don’t think they change much in local AVMs except perhaps at the very top? Still, I think Guy had said somewhere that they should never just be append-list (compare to the QUE value which is always 0-alist, as I show in the last screenshot, but it is also the case in all of them starting from the subj-head rule, so, 3-4-5).

  1. lowest V (lexical entry):

Screen Shot 2020-01-08 at 1.24.22 PM

  1. second V (lexical rule, 3sg):

  1. lowest binary V (subject-head):

  1. lower S (complement-head):

  1. Top S (filler-head):

Okay, so this suggests that the SLASH list is basically underspecified even after the verb has found all of its complements (I think; I still don’t really know how to read append-lists!). By the time it has picked up both subject and complement (i.e. the lower S) it should be SLASH empty. Are both Ivan and chto actually SLASH empty?

1 Like