Extracted-adj rule insisting on extracted or dropped subject; why?

A separate question about the same type, not related to append-lists (I don’t think).

extracted-adj-phrase := basic-extracted-adj-phrase &
  [ SYNSEM [ LOCAL.CAT [ VAL.SPEC < >, POSTHEAD #ph,
                         MC #mc, WH #wh ],
	         NON-LOCAL [ QUE #que, YNQ #ynq, SLASH append-list &
		   [ APPEND < #slash, append-list & [ LIST < [ CAT [ HEAD [ MOD.FIRST [ LOCAL intersective-mod &
                                                   [ CAT [ HEAD #head,
                                                           VAL #val,
                                                           POSTHEAD #ph,
                                                           MC #mc ],
                                                     CONT.HOOK #hook,
                                                     CTXT #ctxt ] ] ],
                              VAL [ SPEC < >,
                                    SUBJ olist,
                                    COMPS olist,
                                    SPR olist ] ] ] > ] > ] ] ],
    HEAD-DTR.SYNSEM canonical-synsem & [ L-QUE -, LOCAL local & [ CAT [ WH #wh,
		                            HEAD #head & verb,
		                            VAL #val & [ SPEC < > ], POSTHEAD #ph,
                   MC #mc ], CONT.HOOK #hook,
                   CTXT #ctxt  ],
             NON-LOCAL [ QUE #que, SLASH #slash, YNQ #ynq ], MODIFIED notmod ],
              C-CONT [ HOOK #hook,
         RELS.LIST < >,
	     HCONS.LIST < >,
	     ICONS.LIST < > ]].

Trying to parse a sentence with three extracted things: who where what do you think saw (in Russian). So, I need the complement extracted first, then the adjunct, then the subject.

I see adjunct extraction appear in the chart but only after subject extraction or after subject drop. So, looks like it cannot apply to something that has SUBJ cons. But why? Nothing in the type (or its super types) appears to constrain the subject that way? Interactive unification works, too (no failure; yes, I’ve read this :slight_smile:)

Could this be related to this?

What did you interatively unify and what was the result? What is in the chart? What are the supertypes of this type?

My first thought is that VAL is copied onto the new element – wouldn’t this include the nonempty SUBJ? That could cause it to fail later on.

The MOD is also an open list, which is bad practice regardless of whether it’s a problem here.

Oh, there is a lot in the chart generally but I don’t need to go far.

Suppose I am parsing sentence (1):

(1) Kto kogo gde ty dumaesh videl?
who whom where you think saw?
Who do you think saw whom [and] where? 

The only parse I get is with where modifying think. I want also a parse where where modifies saw.

In the chart, at the bottom, for saw, I see various edges (bottom right):

Screen Shot 2020-07-14 at 7.12.20 AM

Some of them (304, 276, 153, 125, 78, 42) are ex-adj, but, only the ones that take either ex-subj or subj-opt as the daughter. There is no ex-adj edge that would be using a V as the daughter.

I then interactively unify V[39] (which is the verb saw after the inflectional rule applies) with the daughter of ex-adj rule, so, with 59[sign] here, which succeeds:
Screen Shot 2020-07-14 at 7.16.56 AM

As for VAL features, what should happen in the extracted adjunct rule? If I remove the constraint, the grammar then spins. Looks like it spins on ex-adj / subj-head.

I also reproduced this on a smaller pseudolanguage grammar. Seems like this adjunct extraction rule is unable to apply at the V level, even though I didn’t change any constraints which directly have to do with VAL. The VAL constraints used to be the same in the previous version of the rule (which was erroneously appending the daughter’s SLASH list to the MOD list), which could apply at the V level.

If I remove the #val identity and at the same time if I put back the explicit constraint that the HEAD-DTR SUBJ is non-empty (which apparently was not working for me in the past, so I removed it), then I seem to be getting the parses that I want (and then some).

I don’t really understand why.

But at least no more mysterious behavior, for the time being…

…But I still cannot get an adjunct be extracted before the arguments. Arguments first, then adjuncts - fine. Adjunct first - no.

I think I am confused about append/prepend, lexical threading, and the order of things.

What I am seeing currently is, in a sentence like (2):

(2) gde   kto ty dumaesh lezhit?
    where who you think  lie
"Who do you think lies where?" [rus]

Adjunct extraction applies first, then subject extraction, but on the resulting SLASH list, the extracted subject is actually first on the list. So, looks like lexical threading prepends it, right, to the already existing nonempty list with the adjunct on it? And so for (2), this works sort of by accident, but if I want (3):

(3)  kto gde   ty  dumaesh lezhit?
      who where you think   lie
"Who do you think lies where?" [rus]

I can’t get it, right? Not the version where the adjunct would be extracted from the embedded verb. The extracted subject rule prepended the subject instead of appending it, and so the adjunct cannot attach first.

But can I change this?.. Would I need to change how gap is defined or how all the phrases which currently identify their mother’s SLASH with the head daughter’s are defined?

I can get (3) if I get rid of gap in the subject extraction rule. Which is maybe good but now I have lots and lots of diffs which it will take a while to investigate (then again, we did want to try and get rid of lexical threading anyway). But does it sound like I am on the right track at least, or could this still be salvaged the way it is (with gap in the extracted subject rule), by some other change? (I don’t think so.)

Most of the diffs are of this nature (this is a pseudolanguage):

Screen Shot 2020-07-14 at 5.19.22 PM

Adjunct extraction applies before and after subject extraction.

Now I can no longer rely on gap being non-canonical to say that adjunct extraction must have only canonical subjects in head daughters.

Perhaps that’s OK for now; I was suspicious of the canonical-list solution anyways, it did occur to me before that it could be blocking some valid LDDs.

Thoughts?..

Lexical threading means conceptually, extracted arguments already have their place staked out on the VP’s SLASH list before either the extracted subject or extracted adjunct rule applies. XSUBJ just determines that that placeholder is filled instead of empty.

If you want the subject and adjunct both extracted from the embedded clause to be able to appear fronted in both orders (who where and also where who) then I think you’ll need one of (1) two extracted adjunct rules, one that prepends and the other that appends, (2) two filler rules, one that pulls the 2nd element off SLASH, or (3) a shuffle operator.

If you only want one order or the other it should be possible to be more careful about where the adjunct goes on the SLASH list (possibly even declaring a place for it a priori in the lexical threading approach).

Ooooh, right… You’ve explained this to me before, too. Thanks, Woodley.

OK, I suppose this is then in the category of things which should not be relevant if we try no lexical threading. Will discuss with @ebender.

OK sorry for the confusing thread, but I need to go back to the question of why I am not seeing the adjunct extraction edge in the chart unless I specify that the SUBJ of the head daughter is non-empty (< synsem-min >). I don’t want to do that because then I lose some of the orders, obviously. But if I don’t do this, then I am back to the mysterious behavior described above, where the edge isn’t in the chart but unification succeeds. I thought I fixed it but no (my Russian grammar is too confusing because of its current flexibility; I often don’t notice which combination of rules is at play).

So, this allows adjunct to be extracted first, then subject:

extracted-adj-phrase := basic-extracted-adj-phrase &
  [ SYNSEM [ LOCAL.CAT [ VAL.SPEC < >, POSTHEAD #ph,
                         MC #mc, WH #wh ],
	         NON-LOCAL [ QUE #que, YNQ #ynq, SLASH append-list &
		   [ APPEND < #slash, [ LIST < [ CAT [ HEAD +rp & [ MOD < [ LOCAL intersective-mod &
                                                   [ CAT [ HEAD #head,
                                                           POSTHEAD #ph,
                                                           MC #mc ],
                                                     CONT.HOOK #hook,
                                                     CTXT #ctxt ] ] > ],
                              VAL [ SPEC < >,
                                    SUBJ olist,
                                    COMPS olist,
                                    SPR olist ] ] ] > ] > ] ] ],
    HEAD-DTR.SYNSEM canonical-synsem & [ L-QUE -, LOCAL local & [ CAT [ WH #wh,
		                            HEAD #head & verb,
		                            VAL [  SUBJ < synsem-min >, SPEC < > ], POSTHEAD #ph,
                   MC #mc ], CONT.HOOK #hook,
                   CTXT #ctxt  ],
             NON-LOCAL [ QUE #que, SLASH #slash, YNQ #ynq ], MODIFIED notmod ],
              C-CONT [ HOOK #hook,
         RELS.LIST < >,
	     HCONS.LIST < >,
	     ICONS.LIST < > ]].

But the below doesn’t; why? Is it somehow the same issue that Woodley is explaining? Except I took the type gap out of the subject extraction rule.

extracted-adj-phrase := basic-extracted-adj-phrase &
  [ SYNSEM [ LOCAL.CAT [ VAL.SPEC < >, POSTHEAD #ph,
                         MC #mc, WH #wh ],
	         NON-LOCAL [ QUE #que, YNQ #ynq, SLASH append-list &
		   [ APPEND < #slash, [ LIST < [ CAT [ HEAD +rp & [ MOD < [ LOCAL intersective-mod &
                                                   [ CAT [ HEAD #head,
                                                           POSTHEAD #ph,
                                                           MC #mc ],
                                                     CONT.HOOK #hook,
                                                     CTXT #ctxt ] ] > ],
                              VAL [ SPEC < >,
                                    SUBJ olist,
                                    COMPS olist,
                                    SPR olist ] ] ] > ] > ] ] ],
    HEAD-DTR.SYNSEM canonical-synsem & [ L-QUE -, LOCAL local & [ CAT [ WH #wh,
		                            HEAD #head & verb,
		                            VAL [  SPEC < > ], POSTHEAD #ph,
                   MC #mc ], CONT.HOOK #hook,
                   CTXT #ctxt  ],
             NON-LOCAL [ QUE #que, SLASH #slash, YNQ #ynq ], MODIFIED notmod ],
              C-CONT [ HOOK #hook,
         RELS.LIST < >,
	     HCONS.LIST < >,
	     ICONS.LIST < > ]].

One potentially confounding issue when looking for edges in the chart is packing. It is conceivable that the edge you are looking for did in fact get generated but then packed into another edge and therefore was not displayed.

What happens if you disable packing (-p on the command-line for ACE)?

-Woodley

1 Like

The same for the LKB, if you’re using that. Turn off packing when you’re looking for a particular edge.

1 Like

OK I believe I turned off packing; at least the terminal did not complain and I am able to use other commands like print chart, and see a result of that. So I am assuming I turned off packing. Any way to double check that? I still am not seeing the edge I want in the chart, although I got so confused yesterday that I just started anew today, so, this may be a slightly different grammar at this point.

So, let me start over; for now that’s what I have. And let’s look at a small pseudolanguage grammar so it is less confusing maybe.

I have a type to extract an adjunct and append it to any previously extracted things:

basic-extracted-adj-phrase := head-mod-phrase & head-only & phrasal.

; OZ 2020-07-01 I took out some constraints for now such as #val but it is the same with #val
extracted-adj-phrase-simple := basic-extracted-adj-phrase &
  [ SYNSEM [ LOCAL.CAT [ VAL.SPEC < >, POSTHEAD #ph,
                         MC #mc ],
	     NON-LOCAL.SLASH append-list & [ LIST
		   < [ CAT [ HEAD [ MOD < [ LOCAL intersective-mod &
                                                   [ CAT [ HEAD #head,
                                                           POSTHEAD #ph,
                                                           MC #mc ],
                                                     CONT.HOOK #hook,
                                                     CTXT #ctxt ] ] > ],
                              VAL [ SPEC < >,
                                    SUBJ olist,
                                    COMPS olist,
                                    SPR olist ] ] ] > ] ],
    HEAD-DTR.SYNSEM canonical-synsem &
	   [ LOCAL local &
		   [ CAT [ HEAD #head,
			       POSTHEAD #ph,
                   MC #mc ],
                   CONT.HOOK #hook,
                   CTXT #ctxt ],
	     MODIFIED notmod ],
    C-CONT [ HOOK #hook,
         RELS.LIST < >,
	     HCONS.LIST < >,
	     ICONS.LIST < > ] ].

; Append the  modifier to whatever is on the SLASH list
extracted-adj-last-phrase := extracted-adj-phrase-simple &
  [ SYNSEM [ LOCAL.CAT.WH #wh,
	         NON-LOCAL [ QUE #que, YNQ #ynq, SLASH append-list &
		   [ APPEND < #slash, [ LIST < [ CAT [ HEAD +rp & [ MOD < [ ] > ] ] ] > ] > ] ] ],
    HEAD-DTR.SYNSEM [ LOCAL.CAT [ WH #wh,
		                            HEAD verb,
		                            VAL [ SUBJ < >, SPEC < > ] ],
             NON-LOCAL [ QUE #que, SLASH #slash, YNQ #ynq ] ] ].

Here’s the extracted subject rule, for now as it always was, with a gap, so, lexical threading, head-valence phrase in the supertypes, ultimately (my head daughter’s SLASH is my SLASH):

basic-extracted-subj-phrase := basic-extracted-arg-phrase & head-compositional &
  [ SYNSEM.LOCAL.CAT.VAL [ SUBJ < >,
                           COMPS #comps,
                           SPEC #spec, SPR #spr ],
    HEAD-DTR.SYNSEM [ LOCAL.CAT [ VAL [ SUBJ < gap &
                                             [ LOCAL local &
                                               [ CONT.HOOK.INDEX ref-ind ] ] >,
                                        SPR #spr, COMPS #comps,
                                        SPEC #spec],
                                  MC na ],
                      NON-LOCAL.SLASH append-list ],
    C-CONT [ RELS 0-alist,
             HCONS 0-alist,
             ICONS 0-alist ] ].

In my multiple fronting pseudolanguage, this combination of rules ultimately leads to the right MRS but the tree isn’t quite right:

Screen Shot 2020-07-15 at 2.50.59 PM

What I wanted is for the extracted-adjunct rule to apply to the extracted-subject rule mother, not the the filler-gap rule. But there is something about the extracted subject rule that prevents this, and I am assuming it’s lexical threading?

When I try interactive unification, it works (the extracted-adj-last’s daughter unifies with the extracted-subj edge in the chart). The edge that would result from that is not in the chart:

* (print-chart-toplevel)

 > chart dump:

0-1 [7] WHERE => (where) [4]

1-2 [8] WHO => (who) [5]

0-3 [13] WH-QUES => (where who sleeps) [7 12]
0-3 [14] EX-ADJ-LAST => (where who sleeps) [13]
0-3 [15] ADJ-HEAD => (where who sleeps) [7 12]
0-3 [16] ADJ-HEAD => (where who sleeps) [7 11]
0-3 [19] ADJ-HEAD => (where who sleeps) [7 18]
0-3 [20] ADJ-HEAD => (where who sleeps) [7 17]
1-3 [11] WH-QUES => (who sleeps) [8 10]
1-3 [12] EX-ADJ-LAST => (who sleeps) [11]
1-3 [17] SUBJ-HEAD => (who sleeps) [8 9]
1-3 [18] EX-ADJ-LAST => (who sleeps) [17]
2-3 [9] SLEEPS => (sleeps) [6]
2-3 [10] EX-SUBJ => (sleeps) [9]

NIL
* 

And here’s something interesting that happens if I modify the subject extraction rule as follows, as an experiment:

basic-extracted-subj-phrase := head-nexus-phrase & head-compositional & head-only &
  [ SYNSEM [ LOCAL.CAT.VAL [ SUBJ < >,
                           COMPS #comps,
                           SPEC #spec, SPR #spr ],
             NON-LOCAL.SLASH.APPEND < #slash, [ LIST < #local > ] > ],
    HEAD-DTR.SYNSEM [ LOCAL.CAT [ VAL [ SUBJ < [ LOCAL local & #local &
                                               [ CONT.HOOK.INDEX ref-ind ] ] >,
                                        SPR #spr, COMPS #comps,
                                        SPEC #spec],
                                  MC na ],
                      NON-LOCAL.SLASH append-list & #slash ],
    C-CONT [ RELS 0-alist,
             HCONS 0-alist,
             ICONS 0-alist ] ].

I now do get what looks like the adjunct could in fact have been extracted some time before the application of the filler-gap rule (the additional tree on the left; the bottom S is subject extraction, the other two are both filler-gap), but… no edge! Even in the tree :slight_smile:

Screen Shot 2020-07-15 at 3.08.49 PM

* (print-chart-toplevel)

 > chart dump:

0-1 [7] WHERE => (where) [4]

1-2 [8] WHO => (who) [5]

0-3 [14] WH-QUES => (where who sleeps) [7 13]
0-3 [15] EX-ADJ-LAST => (where who sleeps) [14]
0-3 [16] ADJ-HEAD => (where who sleeps) [7 13]
0-3 [17] WH-QUES => (where who sleeps) [7 12]
0-3 [18] EX-ADJ-LAST => (where who sleeps) [17]
0-3 [19] ADJ-HEAD => (where who sleeps) [7 12]
0-3 [22] ADJ-HEAD => (where who sleeps) [7 21]
0-3 [23] ADJ-HEAD => (where who sleeps) [7 20]
1-3 [12] WH-QUES => (who sleeps) [8 10]
1-3 [13] EX-ADJ-LAST => (who sleeps) [12]
1-3 [20] SUBJ-HEAD => (who sleeps) [8 9]
1-3 [21] EX-ADJ-LAST => (who sleeps) [20]
2-3 [9] SLEEPS => (sleeps) [6]
2-3 [10] EX-SUBJ => (sleeps) [9]
2-3 [11] EX-ADJ-LAST => (sleeps) [10]

And now I’ve managed to get interactive unification to just silently fail(? do nothing) in lkb-fos, by making going back to the original extracted-subj rule, with a gap, and making the following change in the extracted-adjunct rule:

extracted-adj-last-phrase := extracted-adj-phrase-simple &
  [ SYNSEM [ LOCAL.CAT.WH #wh,
	         NON-LOCAL [ QUE #que, YNQ #ynq, SLASH append-list &
		   [ APPEND < #slash, [ LIST < [ CAT [ HEAD +rp & [ MOD < [ ] > ] ] ] > ] > ] ] ],
    HEAD-DTR.SYNSEM [ LOCAL.CAT [ WH #wh,
		                            HEAD verb,
		                            VAL [ SUBJ < [ ] >, SPEC < > ] ],
             NON-LOCAL [ QUE #que, SLASH #slash, YNQ #ynq ] ] ].

Now when I try to interactively unify the ex-subj mother with ex-adj-last’s daughter, nothing happens :). Neither result nor failure. Have not seen this before! I preserved the grammar in case someone wants to see it.

If I try to unify the VP with the ex-adj rule (before ex-subj applies), I get unification result (but no edge).

Your extracted adjunct rule is broken, if I am reading correctly. It appears that in the “basic” type you specify the mother’s SLASH.LIST directly as a single element list, and on the more specific subtype used to instantiate the rule, you specify SLASH.APPEND as the concatenation of the daughter’s slash and the new element. Those two constraints conspire to require the daughter to be SLASH-empty, which is why it cannot apply to the extracted subject rule — at least at a guess.

In the variant where you removed gap from xsubj’s daughter’s SUBJ list, you have created an underspecification as to the contents of that subject’s SLASH value, which is lexically threaded still. As a result, you get two trees: the one you expected, and the other where the fronted “where” fills the possible gap in the SUBJ and the fronted “who” fills the explicit gap created by xsubj. To block it you would have to say something like canonical instead of just removing gap.

I’m working on a small screen so my apologies if I missed something and the above is incorrect! Also I have no explanation for the interactive unification/chart mismatch. I would be happy to look at that in more detail with a copy of the grammar in question.

2 Likes

Oh right! Thanks, Woodley!

I now changed the SLASH.LIST in the supertype to be SLASH.LIST.FIRST (I had done that in the previous iteration of this… this time I forgot to do it).

Hooray, I am now seeing the edge in the chart! Edge 11:

* (print-chart-toplevel)

 > chart dump:

0-1 [7] WHERE => (where) [4]

1-2 [8] WHO => (who) [5]

0-3 [14] WH-QUES => (where who sleeps) [7 13]
0-3 [15] EX-ADJ-LAST => (where who sleeps) [14]
0-3 [16] ADJ-HEAD => (where who sleeps) [7 13]
0-3 [17] ADJ-HEAD => (where who sleeps) [7 12]
0-3 [20] ADJ-HEAD => (where who sleeps) [7 19]
0-3 [21] ADJ-HEAD => (where who sleeps) [7 18]
1-3 [12] WH-QUES => (who sleeps) [8 10]
1-3 [13] EX-ADJ-LAST => (who sleeps) [12]
1-3 [18] SUBJ-HEAD => (who sleeps) [8 9]
1-3 [19] EX-ADJ-LAST => (who sleeps) [18]
2-3 [9] SLEEPS => (sleeps) [6]
2-3 [10] EX-SUBJ => (sleeps) [9]
2-3 [11] EX-ADJ-LAST => (sleeps) [10]

I do now get the extracted elements on the SLASH list in the expected order: first the argument, then the adjunct. So that’s good. That’s edge [11] above.

Now I’d like to unify this edge with the head daughter of the wh-filler-gap rule, which succeeds. Then, I want to unify the non-head daughter of that wh-filler-gap rule with the NP who.

The violation that I now get is the following:

So the word who is MOD-empty, but somehow the wh-rule now wants a MOD-nonempty non-head daughter? I am not sure why though I am pretty sure it has to do with the extracted adjunct. Does something else stand out in the extracted adjunct rule, that would lead to this? It does identify a bunch of things between the modifier’s MOD and its own head daughter, which is what it should be doing. But why does it have this effect on the extracted argument?

Sounds like the wh-rule is taking not the first element off the list but the second one, first? Except the head of that item is noun, not +rp, as it would be if it were actually identifying this thing with the extracted adjunct. The only failure is in the MOD. Does anyone see why? I think the type 1st-head-filler-phrase is the most relevant below with respect to which element is the filler (it’s at the very bottom).

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

; ASF 2011-10-05 changed supertype 'headed-phrase' to more specific 'head-compostional'
; in order to make sure matrix.tdl provides the right semantics.

basic-head-filler-phrase := basic-filler-phrase & head-compositional.

wh-ques-phrase := basic-head-filler-phrase & interrogative-clause & head-final & 1st-head-filler-phrase &
  [ NON-HEAD-DTR.SYNSEM [ NON-LOCAL.QUE.LIST < ref-ind >,
                          LOCAL.CONT.HOOK.ICONS-KEY focus ],
    SYNSEM [ LOCAL.CAT [ MC bool,
                         VAL #val,
                         HEAD verb ],
             NON-LOCAL.QUE #que & 0-alist ],
    HEAD-DTR.SYNSEM [ LOCAL.CAT [ VAL #val &
                                      [ SUBJ < >,
                                        COMPS < > ],
                                  MC na-or-+ ],
                      NON-LOCAL [ SLASH.LIST.FIRST [ ],
                                  QUE #que ] ] ].

1st-head-filler-phrase := basic-filler-phrase & head-compositional &
  [ SYNSEM.NON-LOCAL [ SLASH.LIST #slash,
                       REL #rel,
                       QUE 0-alist,
                       YNQ 0-alist ],
    ARGS < [ SYNSEM.LOCAL #local &
                          [ CAT.HEAD +nrpd ] ],
           [ SYNSEM.NON-LOCAL [ SLASH.LIST < #local . #slash >,
                                REL #rel & 0-alist ] ] > ].