Underfilling
When developing traditional predicate based loglangs, one will inevitably run into the issue of underfilling. This is, what happens when a speaker does not provide an argument for one of the argument slots. For example, "eat" and "go" are transitive verbs in English, but one can state "he eats" and "she goes". What happens to the second argument (y) of the underlying go(x, y) and eat(x,y) predicates ?
Disallow underfilling
The simplest approach is to disallow underfilling entirely. This certainly solves the issue, and seems to be the direction Toaq is going. There's no question of what a missing slot means if there are no missing slots !
The issue is a risk of verbosity and redundancy since every slot must be filled. This is particularly a hassle when turning transitive and ditransitive (and above) verbs into nouns. You can use a short filler word, but then you might end up with something like:
The eater of something gives something to the goer to somewhere
There's also the famous Lojban beginner example:
mi klama zo'e zo'e zo'e zo'e
There are ways to mitigate this. For example, Toaq has many prefixes that eases filling unspecified slots, and the chaining system makes it easy to implicitly fill some slots. This method also encourages lower valency predicates in general, which is good loglang design (since it avoids unicorn castles). However, if you choose this route, you will need many predicates or accept the redundancy, both of which increase verbosity.
Verb families
Another option is that each word or stem represents multiple underlying predicates. That is, instead of just having "eat", you have "eatâ" and "eatâ" that take one or two arguments respectively. This works and is well defined, but has multiple issues: First of all, this greatly complicates dictionary entries since each word now needs at least as many definitions as sub-predicates. Secondly, it doesn't completely solve the problem. Should we also have an "eatâ" verb ? What about a passived eatâ without the the second argument ? Would this be another "eatâ.PASS" meaning ? What exactly is the speaker allowed to drop ?
At worst, i.e. if a user is able to drop any argument like Lojban, then you need 2^n definitions, where n is the arity of the stem. So for a predicate with 4 arguments (e.g. "trade"), that's 16 underlying definitions. It also feels odd, since these definitions are clearly semantically related somehow. It seems we should be able to transform one definition and another systematically, but this model allows each definition to be completely unrelated.
Defaults
To avoid this combinatorial explosion, one can instead set a default per argument. The major downsides are that definitions are still complex, and that there may not be a reasonable constant to use as a default in all contexts. This is especially true in Lojban where users are encouraged arguments to be left to context, and rarely is 1s, for example, a good, universal default. As another example, is "it" (rai in Toaq, zo'e or lo srana in Lojban) always a good default for "I eat [it]" ? One can make the default depend on the context, or be some sort of logical formula, but these have complexities similar to the next section.
Existential instantiation
One of the most tempting ways to fill an empty space is with a bare existential. We make no claims about the unfilled slots except that there's something, anything that can be substituted there that makes the sentence true. For example, "I eat" can be formalized as
âx. eat(Me, x)
This also works with passivation:
she was seen
ignoring tense, formalizes to
âx. see(x, She)
This extends equally well to predicates with many places. Consider:
trade(a, b, x, y) := a trades x for y with b
We can formalize, e.g.
He trades for jewels
to:
âx. ây. trade(He, y, x, Jewels)
Unfortunately, there's a caveat here: scope interactions. In formal logic, quantifiers strongly scope over everything to their right. This isn't an issue if you only use existential variables and constants, but you cannot freely interchange universal (â) and existential operators (as well as other more obscure operators). Negation also scopes over the right, so it interacts with the orders of existentials as well. This can lead to surprises, and worse, depending on your syntax, ambiguities.
fe ro malpre naku nelci
X2 all jerk not like
^ ^ ^
This is a Lojban sentence that means roughly, "all jerks are not liked", but the existential term could be introduced in any of the three marked places, and they would each mean something different ! This is a risk with all case based loglangs that allow underfilling.
One can avoid the above ambiguity if the language has a firm word order. In such a case,
the existentials are instantiated exactly where the term is omitted in the sentence. This may lead to surprises. For example:
She gave ___ to all of them
We fill the ___ with an existential and end up with something like:
[She]. âx. ây â Them. give(She, x, y)
This is, there is some one thing that gives to all of them. This isn't how giving works ! There are some details around plural logic I'm ignoring, but this should make the dangers intuitively clear. One slot left thoughtlessly vacant can completely change the meaning of a sentence.
Innermost scope
One way to manage this is to say existential instantiation always occurs in the innermost scope. That is, all implicit existentials are moved to the furthest right. One can view this as the creation of a new verb with that slot filled with an existential in its definition. E.g., if we define as an underfilled slot in that location:
give(a, , b) := âx. give(a, x, b)
I.e. we make a new verb with arity n-1. This solve all our issues with bare universal instantiations, e.g.:
ây â Them. give(She, , y)
ây â Them. (âx. give(She, x, y))
So now there's a gift for each giftee and there are no other constraints. This approach still isn't perfect: It can have some surprising interactions with negation. Consider the sentence
I do not go.
Firstly has to decide is where the negation occurs. One choice is that it effects just the verb. Then this is
âx. ÂŹgo(Me, x)
This simply means there's somewhere I don't go, which claims almost nothing. For example, of course I do not go to the center of the sun, the inside of a breadbox, nor the platonic ideal of a sphere. These all satisfy the above logical expression, but they are much weaker claims than what someone usually means when they say "I do not go". Another choice is to let negation scope over the existentials (or the entire clause, but I wish to avoid digressing into a discussion of negation). Then we have:
ÂŹâx. go(Me, x)
Pushing the negation through we get:
âx. ÂŹgo(Me, x)
This is, for all places and things, I don't go there. Usually there's some contextual event constraining this, so this doesn't mean I never go anywhere ever. This seems correct in isolation, but some will claim that this has a different semantic meaning then not going in context. Consider the exchange.
Do you like concerts ?
I don't go. I go to the movies.
The last two sentences contradict in this model. One might argue this is where a discerning loglanger would say a pronoun is mandatory. Perhaps this is just pragmatics.
Conclusion
Which technique do you use or prefer and why ? Do you have any ideas not mentioned here ? How should existential instantiation How do these techniques interacts with negative events ? There's even more discussion on the Toaq wiki.