Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's behavior is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to have CASE - or so I thought. It wouldn't be enough that the NP gets assigned CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in that constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures for the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there is no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I have a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
Hi Dag,
I looked at the XLE code, and there is special code that changes explicit subsumption to regular set subsumption if the f-structure has a predicate (which ! does). I don't remember adding this code, so I don't know what the linguistic justification is for it was.
Ron or Tracy would be better candidates for explaining the original justification for explicit subsumption in general.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's behavior is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to have CASE - or so I thought. It wouldn't be enough that the NP gets assigned CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in that constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures for the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there is no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I have a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
Hi John,
thanks, that explains the XLE's behavior. I think you are right that explicit subsumption isn't used that much, but there has been some theoretical interest and for that reason it would be useful to be able to test it in various contexts without conversion to regular set subsumption. One day...
Dag
On Tue, 2012-05-15 at 15:25 -0700, John.Maxwell@parc.com wrote:
Hi Dag,
I looked at the XLE code, and there is special code that changes explicit subsumption to regular set subsumption if the f-structure has a predicate (which ! does). I don't remember adding this code, so I don't know what the linguistic justification is for it was.
Ron or Tracy would be better candidates for explaining the original justification for explicit subsumption in general.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's behavior is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to have CASE - or so I thought. It wouldn't be enough that the NP gets assigned CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in that constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures for the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there is no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I have a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
Hi,
So the effect here is that the externally defined CASE feature is propagated down the subsumption chain, as if it was an equality? But then, if there were also an equation (^ XXX) = ! on the S, we should see that the f-structure of the XXX has the case feature that Dag says we don't see when we look at the f-structure corresponding to the S. Is that what's happening?
In any event, I don't remember this particular twist or any motivation for it.
The closest I can come (which isn't too close, actually) is that this may have been tied up with an issue that Annie and I discussed in our paper on German partial VP fronting (LFG02), one of the papers that came out of our early subsumption work. The gloss of an exemplar sentence was
[The book to give]VP seemed Hans the girl.
meaning
Hans seemed to give the girl the book.
In our account we asserted that the f-structure of the topicalized VP is a subsumer of the f-structure complement of "seemed", which also includes the NP's that appeared in normal complement position. So we had the assertions (! TOPIC) = ! ! << (^ XCOMP* XCOMP) on the fronted VP. This reassembled everything as needed, but also kept as a separate unit the material that was topicalized, e.g. to account for discourse or other phenomena.
We noted that this created a problem for the original KB 82 definition of completeness. The fronted VP contains a PRED that is missing some of its arguments, and therefore would be marked as invalid according to the original definition of local completeness. We extended the definition so that an f-structure would be complete if it subsumed a complete f-structure, that is, completeness is tested only at the top of a chain of subsumptions.
So this has something to do with an interaction of subsumption with PRED-containing f-structures, and maybe that somehow impacted the implementation in this particular way. But it doesn't obviously relate to the problem at hand. The only point of the analogy is that the completeness existential constraint is evaluated on a structure that has assembled information from different levels of the subsumption chain.
I haven't found (and don't remember) any discussion of this situation. Maybe Annie does?
--Ron
On 5/16/12 10:17 AM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Hi John,
thanks, that explains the XLE's behavior. I think you are right that explicit subsumption isn't used that much, but there has been some theoretical interest and for that reason it would be useful to be able to test it in various contexts without conversion to regular set subsumption. One day...
Dag
On Tue, 2012-05-15 at 15:25 -0700, John.Maxwell@parc.com wrote:
Hi Dag,
I looked at the XLE code, and there is special code that changes explicit subsumption to regular set subsumption if the f-structure has a predicate (which ! does). I don't remember adding this code, so I don't know what the linguistic justification is for it was.
Ron or Tracy would be better candidates for explaining the original justification for explicit subsumption in general.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's behavior is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to have CASE - or so I thought. It wouldn't be enough that the NP gets assigned CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in that constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures
for
the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there
is
no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I
have
a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
Hi Ron,
I don't think that the externally defined CASE feature is being propagated down the subsumption chain. Rather, the sub-c constraint is passed up the subsumption link and satisfied by the upper f-structure. This is just like what happens if you have an (^ TENSE) constraint where ^ is a set. The TENSE sub-c constraint is passed to each element of the set, and the fact that the set itself doesn't have a TENSE feature is ignored.
Thanks for the partial VP fronting example. I vaguely remembered it, but I wasn't sure it was relevant.
Cheers,
John
On 5/16/12 3:36 PM, "Ron Kaplan" Ron.Kaplan@microsoft.com wrote:
Hi,
So the effect here is that the externally defined CASE feature is propagated down the subsumption chain, as if it was an equality? But then, if there were also an equation (^ XXX) = ! on the S, we should see that the f-structure of the XXX has the case feature that Dag says we don't see when we look at the f-structure corresponding to the S. Is that what's happening?
In any event, I don't remember this particular twist or any motivation for it.
The closest I can come (which isn't too close, actually) is that this may have been tied up with an issue that Annie and I discussed in our paper on German partial VP fronting (LFG02), one of the papers that came out of our early subsumption work. The gloss of an exemplar sentence was
[The book to give]VP seemed Hans the girl.
meaning
Hans seemed to give the girl the book.
In our account we asserted that the f-structure of the topicalized VP is a subsumer of the f-structure complement of "seemed", which also includes the NP's that appeared in normal complement position. So we had the assertions (! TOPIC) = ! ! << (^ XCOMP* XCOMP) on the fronted VP. This reassembled everything as needed, but also kept as a separate unit the material that was topicalized, e.g. to account for discourse or other phenomena.
We noted that this created a problem for the original KB 82 definition of completeness. The fronted VP contains a PRED that is missing some of its arguments, and therefore would be marked as invalid according to the original definition of local completeness. We extended the definition so that an f-structure would be complete if it subsumed a complete f-structure, that is, completeness is tested only at the top of a chain of subsumptions.
So this has something to do with an interaction of subsumption with PRED-containing f-structures, and maybe that somehow impacted the implementation in this particular way. But it doesn't obviously relate to the problem at hand. The only point of the analogy is that the completeness existential constraint is evaluated on a structure that has assembled information from different levels of the subsumption chain.
I haven't found (and don't remember) any discussion of this situation. Maybe Annie does?
--Ron
On 5/16/12 10:17 AM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Hi John,
thanks, that explains the XLE's behavior. I think you are right that explicit subsumption isn't used that much, but there has been some theoretical interest and for that reason it would be useful to be able to test it in various contexts without conversion to regular set subsumption. One day...
Dag
On Tue, 2012-05-15 at 15:25 -0700, John.Maxwell@parc.com wrote:
Hi Dag,
I looked at the XLE code, and there is special code that changes explicit subsumption to regular set subsumption if the f-structure has a predicate (which ! does). I don't remember adding this code, so I don't know what the linguistic justification is for it was.
Ron or Tracy would be better candidates for explaining the original justification for explicit subsumption in general.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's
behavior
is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to
have
CASE - or so I thought. It wouldn't be enough that the NP gets
assigned
CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in
that
constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures
for
the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there
is
no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I
have
a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
Hi,
yes, John is right that it is not the CASE feature being propagated down, but the sub-c constraint being passed up. I guess it is possible to argue that sub-c constraints should be passed to the subsumee, but the really counter-intuitive thing here is that they are ignored in the subsumer. In Ron's example this would have the effect that if the topicalized partial VP contained a sub-c constraint, that constraint wouldn't be evaluated there, but on the complete assembled VP. I think that behaviour is only justified in sets, it is hard to see that it would be needed elsewhere.
I attach a picture of what happens. I am not saying that this is a particularly insightful analysis, I was just playing around with what subsumption can be used for and noticed this weird behaviour. The f-structure of the S does not contain CASE, but that of the NP does since the verb has (^ OBJ CASE) = ACC. The f-structure of the S is orphaned, since the intention was to use it only to test for the presence of CASE and otherwise just pass up its features to the NP.
Dag
On Wed, 2012-05-16 at 16:34 -0700, John.Maxwell@parc.com wrote:
Hi Ron,
I don't think that the externally defined CASE feature is being propagated down the subsumption chain. Rather, the sub-c constraint is passed up the subsumption link and satisfied by the upper f-structure. This is just like what happens if you have an (^ TENSE) constraint where ^ is a set. The TENSE sub-c constraint is passed to each element of the set, and the fact that the set itself doesn't have a TENSE feature is ignored.
Thanks for the partial VP fronting example. I vaguely remembered it, but I wasn't sure it was relevant.
Cheers,
John
On 5/16/12 3:36 PM, "Ron Kaplan" Ron.Kaplan@microsoft.com wrote:
Hi,
So the effect here is that the externally defined CASE feature is propagated down the subsumption chain, as if it was an equality? But then, if there were also an equation (^ XXX) = ! on the S, we should see that the f-structure of the XXX has the case feature that Dag says we don't see when we look at the f-structure corresponding to the S. Is that what's happening?
In any event, I don't remember this particular twist or any motivation for it.
The closest I can come (which isn't too close, actually) is that this may have been tied up with an issue that Annie and I discussed in our paper on German partial VP fronting (LFG02), one of the papers that came out of our early subsumption work. The gloss of an exemplar sentence was
[The book to give]VP seemed Hans the girl.
meaning
Hans seemed to give the girl the book.
In our account we asserted that the f-structure of the topicalized VP is a subsumer of the f-structure complement of "seemed", which also includes the NP's that appeared in normal complement position. So we had the assertions (! TOPIC) = ! ! << (^ XCOMP* XCOMP) on the fronted VP. This reassembled everything as needed, but also kept as a separate unit the material that was topicalized, e.g. to account for discourse or other phenomena.
We noted that this created a problem for the original KB 82 definition of completeness. The fronted VP contains a PRED that is missing some of its arguments, and therefore would be marked as invalid according to the original definition of local completeness. We extended the definition so that an f-structure would be complete if it subsumed a complete f-structure, that is, completeness is tested only at the top of a chain of subsumptions.
So this has something to do with an interaction of subsumption with PRED-containing f-structures, and maybe that somehow impacted the implementation in this particular way. But it doesn't obviously relate to the problem at hand. The only point of the analogy is that the completeness existential constraint is evaluated on a structure that has assembled information from different levels of the subsumption chain.
I haven't found (and don't remember) any discussion of this situation. Maybe Annie does?
--Ron
On 5/16/12 10:17 AM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Hi John,
thanks, that explains the XLE's behavior. I think you are right that explicit subsumption isn't used that much, but there has been some theoretical interest and for that reason it would be useful to be able to test it in various contexts without conversion to regular set subsumption. One day...
Dag
On Tue, 2012-05-15 at 15:25 -0700, John.Maxwell@parc.com wrote:
Hi Dag,
I looked at the XLE code, and there is special code that changes explicit subsumption to regular set subsumption if the f-structure has a predicate (which ! does). I don't remember adding this code, so I don't know what the linguistic justification is for it was.
Ron or Tracy would be better candidates for explaining the original justification for explicit subsumption in general.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's
behavior
is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to
have
CASE - or so I thought. It wouldn't be enough that the NP gets
assigned
CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in
that
constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures
for
the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there
is
no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I
have
a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
OK, I presumed that the implicit distribution was somehow moving the external structures down. But this now is much closer to the completeness issue, and so that may now be the best explanation of why the code is operating in this way. Completeness constraints (relevant only to Pred-containing structures) do have to move up according to our proposal, maybe the implementation is not distinguishing those from other constraints.
I wonder whether constraints on non-distributive attributes also move up, if this is being assimilated to the set-subsumption machinery.
Ron
On 5/17/12 3:13 AM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Hi,
yes, John is right that it is not the CASE feature being propagated down, but the sub-c constraint being passed up. I guess it is possible to argue that sub-c constraints should be passed to the subsumee, but the really counter-intuitive thing here is that they are ignored in the subsumer. In Ron's example this would have the effect that if the topicalized partial VP contained a sub-c constraint, that constraint wouldn't be evaluated there, but on the complete assembled VP. I think that behaviour is only justified in sets, it is hard to see that it would be needed elsewhere.
I attach a picture of what happens. I am not saying that this is a particularly insightful analysis, I was just playing around with what subsumption can be used for and noticed this weird behaviour. The f-structure of the S does not contain CASE, but that of the NP does since the verb has (^ OBJ CASE) = ACC. The f-structure of the S is orphaned, since the intention was to use it only to test for the presence of CASE and otherwise just pass up its features to the NP.
Dag
On Wed, 2012-05-16 at 16:34 -0700, John.Maxwell@parc.com wrote:
Hi Ron,
I don't think that the externally defined CASE feature is being propagated down the subsumption chain. Rather, the sub-c constraint is passed up the subsumption link and satisfied by the upper f-structure. This is just like what happens if you have an (^ TENSE) constraint where ^ is a set. The TENSE sub-c constraint is passed to each element of the set, and the fact that the set itself doesn't have a TENSE feature is ignored.
Thanks for the partial VP fronting example. I vaguely remembered it, but I wasn't sure it was relevant.
Cheers,
John
On 5/16/12 3:36 PM, "Ron Kaplan" Ron.Kaplan@microsoft.com wrote:
Hi,
So the effect here is that the externally defined CASE feature is propagated down the subsumption chain, as if it was an equality? But then, if there were also an equation (^ XXX) = ! on the S, we should
see
that the f-structure of the XXX has the case feature that Dag says we don't see when we look at the f-structure corresponding to the S. Is
that
what's happening?
In any event, I don't remember this particular twist or any
motivation
for it.
The closest I can come (which isn't too close, actually) is that this may have been tied up with an issue that Annie and I discussed in our paper on German partial VP fronting (LFG02), one of the papers that
came
out of our early subsumption work. The gloss of an exemplar sentence
was
[The book to give]VP seemed Hans the girl.
meaning
Hans seemed to give the girl the book.
In our account we asserted that the f-structure of the topicalized VP
is a
subsumer of the f-structure complement of "seemed", which also includes the NP's that appeared in normal complement position. So we had the assertions (! TOPIC) = ! ! << (^ XCOMP* XCOMP) on the fronted VP. This reassembled everything as needed, but also
kept as
a separate unit the material that was topicalized, e.g. to account for discourse or other phenomena.
We noted that this created a problem for the original KB 82
definition
of completeness. The fronted VP contains a PRED that is missing some
of
its arguments, and therefore would be marked as invalid according to
the
original definition of local completeness. We extended the definition
so
that an f-structure would be complete if it subsumed a complete f-structure, that is, completeness is tested only at the top of a
chain of
subsumptions.
So this has something to do with an interaction of subsumption with PRED-containing f-structures, and maybe that somehow impacted the implementation in this particular way. But it doesn't obviously
relate to
the problem at hand. The only point of the analogy is that the completeness existential constraint is evaluated on a structure that
has
assembled information from different levels of the subsumption chain.
I haven't found (and don't remember) any discussion of this
situation.
Maybe Annie does?
--Ron
On 5/16/12 10:17 AM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Hi John,
thanks, that explains the XLE's behavior. I think you are right that explicit subsumption isn't used that much, but there has been some theoretical interest and for that reason it would be useful to be able to test it in various contexts without conversion to regular set subsumption. One day...
Dag
On Tue, 2012-05-15 at 15:25 -0700, John.Maxwell@parc.com wrote:
Hi Dag,
I looked at the XLE code, and there is special code that changes explicit subsumption to regular set subsumption if the f-structure has a predicate (which ! does). I don't remember adding this code, so I don't know what the linguistic justification is for it was.
Ron or Tracy would be better candidates for explaining the original justification for explicit subsumption in general.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's
behavior
is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's
that
have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from
the
f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to
have
CASE - or so I thought. It wouldn't be enough that the NP gets
assigned
CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption
says
that it behaves differently from implicit subsumption (in sets) in
that
constraining equations don't get distributed. But as it happens,
XLE
accepts a solution where S in itself has no case, but the NP gets
case
from the verb. So even though it displays two different
f-structures
for
the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)),
forcing
local satisfaction of the existential constraint. In that case,
there
is
no need to use subsumption at all, of course. So
implementation-wise I
am ok, but I am interested in subsumption from a theoretical point
of
view as well, so if anyone can help explain XLE's behavior and
whether
there is a particular theoretical reason for it, I'd be grateful. I
have
a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
Hi,
One possible reason for converting explicit subsumption to regular set subsumption in the presence of a predicate is that if you didn't do that, then the predicate would be incomplete on the subsumee if one of the predicate's arguments were filled by the subsumer.
As far as I know, explicit subsumption isn't being used very much.
Cheers,
John
On 5/15/12 1:36 PM, "Dag Haug" d.t.t.haug@ifikk.uio.no wrote:
Dear all,
I have a problem understanding how subsumption and constraining equations work together in the XLE. As far as I can see, XLE's behavior is different from what the documentation says, but I am not sure I understand.
The basic problem is this: I want to allow nominalizations of S's that have a CASE value but not other S's. The rule I use is this:
NP --> { N' | S: ! << ^ (! CASE) }
So an NP can expand to S, in which case the S's f-structure should subsume that of the NP, so all the information gets passed up from the f-structure of the S to the f-structure of the NP. Then there is a constraining/existential equation requiring the S's f-structure to have CASE - or so I thought. It wouldn't be enough that the NP gets assigned CASE from above, so to speak.
If I read it correctly, he documentation of explicit subsumption says that it behaves differently from implicit subsumption (in sets) in that constraining equations don't get distributed. But as it happens, XLE accepts a solution where S in itself has no case, but the NP gets case from the verb. So even though it displays two different f-structures for the NP and the S (since they differ in CASE), it allows for the existential constraint to be satisfied in the "wrong" f-structure.
I can achieve the effect I want by adding @(COMPLETE(! CASE)), forcing local satisfaction of the existential constraint. In that case, there is no need to use subsumption at all, of course. So implementation-wise I am ok, but I am interested in subsumption from a theoretical point of view as well, so if anyone can help explain XLE's behavior and whether there is a particular theoretical reason for it, I'd be grateful. I have a minimal implementation which recreates the problem, if anyone is interested.
Best, Dag Haug
ParGram mailing list ParGram@mailman.uni-konstanz.de https://mailman.uni-konstanz.de/mailman/listinfo/pargram
-
Dag Haug -
John.Maxwell＠parc.com -
Ron Kaplan -
Ron Kaplan