[YG Conlang Archives] > [engelang group] > messages [Date Index] [Thread Index] >

[Date Prev] [Date Next] [Thread Prev] [Thread Next]

Xorban: Proposal for -k-, -b-

Sorry for the length of this.  The proposal itself is relatively simple IMO.  You can skip to it about half the way down to "PROPOSAL".

In terms of argument structure and corresponding semantics, let's review what we already have.  Basically, Xorban imports Lojban predicates and transforms them straightforwardly using argument separator -k-:

x1 broda x2 x3 ... => brdakeki(kX)*

We also have the separator -b-, which adds an agentive argument marked as a {bA}  There is an open proposal to change -b- to be a unary operator prefix b- like recently changed f-.

In order to explicitly "genericize" i.e. demote an argument, Xorban has {o'e} as in { brd(Xk)*o'e(kX)* }, every individual appearance of which I would propose to be interpreted as "lY smY" where Y is a unique anonymous variable; I suggest introducing Y just in case "la sma" by itself wasn't vague enough, as there is still confusion about the exact semantics of "l-" and "l- sm-.  I believe there is shaky consensus on {o'e} within the current system.

There is an open question about the semantics of eliding (and adding) arguments at the end of the structure.  I had assumed that elided arguments were implicit and equivalent to {o'e}, but another interpretation is that any explicit valency change signifies a different predicate.  In practice the latter interpretation would likely be implemented such that stems usually signified a single predicate or a family of similar predicates, and explicit arities would signify variant argument orders assigned based on frequency of occurrence.

Regardless one's preferred interpretation of elision, there is a general desire to make things reasonably (if not maximally) brief and minimize the monotonous use of "o'e".  And has proposed this.

On Wed, Aug 29, 2012 at 8:57 PM, And Rosta <and.rosta@hidden.email> wrote:

Another possibility would be to change the morphology of predicates to XX-bV-cV-dV, where:
1. bV, cV, dV are each omissible (as long as one remains)
2. xxb-V, xxc-V, xxd-V are the same predicate (just with different arguments left implicit)

Also:

On Thu, Aug 30, 2012 at 8:52 PM, And Rosta <and.rosta@hidden.email> wrote: 
I like making bV an operator.

But I think the fate of bV needs to be considered also in the context of whether argument ellipsis occurs, e.g. whether triadic tvl- can be given only one or two overt variables, and if so, which of the three arguments can be left implicit. I think that for brevity's sake it's good if any argument can be left implicit, and to achieve this aim you'd have to fiddle with the morphology of predicates in the way I suggested in another message: instead of CCC-V-k-V-k-V, you'd have CC-(C1-V)-(C2-V)-(C3-V), where any of C1/C2/C3-V are omissible, as long as one remains, and CC+C1, CC+C2, CC+C3 are each sufficient to uniquely identify the predicate. Under this scheme, the consonants could be drawn from pools where each pool is associated with a semantic protorole (like Mike's A,P,T). In a system like this, the need for bV would be diminished, perhaps to the extent where on balance it is done without.

The chief benefits of And's system as I see them seem to be: 1. it's simple; 2. one would less often have to use "o'e"; 3.every argument is marked for protorole, which makes things obvious.  The drawbacks are:  1. no matter how you slice it, it effectively adds a consonant to every predicate stem (note that the argument prefixes must be mutually exclusive from operator prefixes, and every stem will have to be terminated by one of these few);  2. it's more powerful than needed:  given a three-place predicate, there are two variants each for eliding one of three arguments, and there are six variants for eliding no arguments.  A default argument order would (or at least could) settle out based on a protorole salience hierarchy C1 > C2 > C3, but if that happens, then the rewards of fully explicit protorole marking seem to be diminished. If fact we will never need the proposed degree of explicitness wrt to protorole marking except when two arguments are elided.  When only one argument is elided, we only need to know which is elided, which is to say we only need partial explicitness.  When none is elided, we don't need any protorole marking, because the ordering already gives it.  This is all arguably bearable, of course, in light of the benefits.  But it does raise the question of whether we could find a more efficient system, one not adding phonological material to stems, and one not carrying redundant protorole marking.

Before giving my own proposal, I would like to cite an example Xorban sentence that I have given elsewhere.

da djna le slne li kmfi lo frklfto ju ctkake ju gnreba ju nrklekiba plnako.
“John X, barrel S, room K, forklift F: X is pushing on S (simultaneously) X is rolling S (simultaneously) X is putting S into K (simultaneously) X is using F.”
“John X, barrel S, room K, forklift F: X is pushing & rolling S into K using F.”

I noticed a couple of things that seemed unsatisfactory when creating this.  First, I wished to add a patient to "plnako"="A uses O" to create "A uses O on E", but I can't in the current system.  Secondly, "nrklekiba" just doesn't seem right.  "nrkleki" means "E enters I" and "nrklekiba" means "A makes E enters I", but the A argument is at the end.  It's not just the obvious salience hierarchy violation that bothers me, it's that in one sentence we have three different numbered places for "A" - first place "ctkake" and "plnako", second in "gnreba" and third in "nrklekiba".  That seems chaotic. 


PROPOSAL

The first step seems to be this:  make "b" the first (optional) argument separator, and define it to separate an agent from a patient.  In other words, if "b" appears, then the first argument is an agent and the second is a patient.  Some examples:

spfe "E is broken" => spfabe "A breaks E"
nrkleki "E enters I" => nrklabeki "A puts E into I"
plnaki "A uses I" => plnabeki "A does something to E using I"

That should be mostly clear, but there is an important difference between "plnaki" and the other two formulas that needs to be noted.  The first two predicates are defined as primitively patientive and non-agentive, so when -b- is applied, an agent is added to the structure in the first place, and the others are moved one place forward.  In "plnaki", the predicate structure is defined as primitively non-patientive and agentive, so when -b- is applied, the agent stays in the first place, a patient is added in the second, and the others are moved one place forward.

So in general then, predicates would fall into two *semantic* classes.  (Syntactically, all predicates are still the same.)  Let's look at argument structure permutations with "o'e". For one-place patientives we have:

spfe "E is broken" =>
- spfabe "A breaks E"
- spfo'ebe "E gets broken"

spfo'e "Things are broken" =>
- spfabo'e "A breaks things"
- spfo'ebo'e "Things get broken"

That's all there is for patientive monads.  I don't know if we want to use Lojban spofu-x2, but if so, just add -ki.  In this system, when -ki is dropped, it's interpreted as -ko'e. 

A more interesting example is cusku, meaning "x1 (agent) expresses/says x2 (sedu'u/text/lu'e concept) for audience x3 via expressive medium x4."  So the question is how to import this.  Even Lojban says that x1 is an agent, so that seems an easy choice.  The next question is do we have a patient (we don't necessarily need one since we already have an agent, but we will always need at least either an agent or a patient.) Without getting sidetracked with "why", let's choose x3, the audience.  (Actually, it's not super-critical which we choose, since Xorban marks everything with a variable, but we do want some consistency.)  Ignoring x4, that leaves x2, which has to be a k-argument.  The last question is do we want this predicate to be patientive or agentive, and theoretically it could be either.  Again without getting sidetracked, let's go with agentive. 

The full predicate is cskabeki "A tells E (audience) I (proposition/narrative)"  From this via elision we get:

cskabe "A tells E"
cskaki "A says I"
cska "A says/tells"

Because cskabeki is an agentive, the argument after the stem will always be the agent.  In order to demote it we have to use "o'e"

csko'ebe "E was told"
csko'eki "I was said"
csko'ebeki "E was told I"

IMO that's a relatively small drawback given that these are marked and probably less common forms anyway, but it's fair to note this disadvantage.  Using two-place patientive nrklabeki as an example, here's the full paradigm of CCC_(b_)(k_) predicates with {o'e}:

nrkle "E enters", nrkleki "E enters I" =>
- nrklabe "A inserts E", nrklabeki "A puts E in I"
- nrklo'ebe "E is inserted", nrklo'ebeki "E is put in I"

nrklo'e "Things enter", nrklo'eki "I is entered" =>
- nrklabo'e "A inserts things", nrklabo'eki "A puts things in I"
- nrklo'ebo'e "Things are inserted", nrklo'ebo'eki "Things are put in I"

Multiple -k- can be defined if desired, hopefully constrained by the non-silliness principle.  While b-insertion moves k-arguments forward, it never changes the semantics of places when counted by -k-.  In other words, the first, second and third -k-arguments meaning X, Y and Z will mean X, Y, Z regardless of the number of b-insertions.  Speaking of which, higher agents are possible if you need them:

spfe "E is broken" => spfabe "A breaks E" => spfobabe "O makes A break E"
nrkleki "E enters I" => nrklabeki "A puts E into I" => nrklobabeki "O makes A put E into I"
plnaki "A uses I" => plnabeki "A does something to E using I" => plnobabeki "O makes A do something to E using I"
spfa'abe'ebobabe "I[me] make you make O make A break E"

Remember with agent-oriented plnabeki, the first -b- introduces a patient, the second the higher agent. Note that in any bXb, X is technically both an agent and a patient.  As stated earlier, 'if "b" appears, then the first (left) argument is an agent and the second (right) is a patient'.  The salience hierarchy can be generalized as follows:

- . . . > a3 > a2 > a1 > p > k1 > k2 > k3 > . . .


The production rules would be:

- simple-formula := CCC* V(‘V)* ( b V(‘V)*)* ( k V(‘V)*)*


... which allows any number of -b- and -k- so long as all -b- precede all -k-.  The rules for anchoring the argument separators against the salience hierarchy are as follows:

- the Nth agent precedes the Nth -b- counting backwards
- the patient follows the rightmost -b-
- the Nth k-argument follows the Nth -k- (always)
- if no -b- appears, the argument following the stem is either patient or lowest agent, as determined lexically.