Is there a possible way for list difference to work? (figure from: Abeillé, A., & Borsley, R. D. (2021). Basic properties and elements. Head-driven phrase structure grammar: The handbook, 3-45.)
More explicitly, I am working with a scenario where I need to delete a single element from the list (basically a list difference with a singleton). Suppose that I have a lexical rule and I have a pointer in the input identified with some element in a list (so that we have some information of its location in the list, but not exactly which). I hope that the output can have a list with only that element removed.
[ SYNSEM... [LIST < [], ..., ..., [] > ],
DTR.SYNSEM... [LIST < [], ..., #ptr, ..., [] >,
PTR #ptr ] ]
The good thing is that I know that the maximum length of the list could not exceed 3. In practicality, however, it is still not possible to make an exhaustive series of rules, because some of the elements in the list may be underspecified and can have successful unification with whatever thing in the pointer. For example, if I have the following:
[ SYNSEM... [ LIST < #first . #rest > ],
DTR.SYNSEM... [ LIST [ FIRST #first,
REST [ FIRST #ptr,
REST #rest ] ],
PTR #ptr ] ]
It is possible that originally PTR points to #first instead, but LIST.REST.FIRST is underspecified (maybe the only constraint is *avm* or *synsem-min*), so it has no problem in unification. This means that eventually the rule will be applied in this particular circumstance, and we will have < #ptr, #ptr, ... > in the input’s LIST, which is not wanted – it should be precluded as the intention of the rule is to delete the *second* element of the list.