Hallo!

R A Brown wrote:

> Jörg Rhiemeier wrote:
> > Hallo!
> >
> > R A Brown wrote:
> [snip]
> >>I must have another read of Jeff's paper and see if I cannot do
> >>something more than just give brz a "hexadecimal phonology".
> >
> >
> > 'brz' is definitely an idea that deserves further exploration.
> 
> Thanks. I was looking again at Jeff's paper last evening. I wonder, in
> fact, how the advocates of Loglan and Lojban view his paper. Would they
> consider his ideas as outlines for an near-optimal loglang, I wonder.

I'd rather guess that they are too entrenched in their "done deals"
of loglangs.  After all, Loglan still exists side by side with
Lojban.  It's the same as with auxlangs.

> Certainly, 'Plan B' is the outline for a engelang, but the sort of
> syntax Jeff proposes seems to me rather different from that of a loglang
> which, if I have understood aright, is based on clausal form logic.
> 
> What Jeff seems to be working towards is a method in which a stream of
> characters (whether alphabetic or of binary digits or, indeed, any other
> characters such as Tengwar) can be _unambiguously_ :
> (a) broken up into morphemes or, as Jeff calls them, 'affixes';
> (b) the affixes reconstituted as a binary tree.
> 
> (a) appeals to me very much as this is precisely what I have tried to
> achieve in the various incarnations of briefscript, BrSc, BrScA, BrScB,
> ~bax etc - self-segregating morphemes. For that very reason, I am
> looking at this closely.

There are many ways to achieve self-segregation.  Jeff's solution
is elegant and original, but far from the only one.  A simple
self-segregation system I once came up with has morphemes of the
following structures:

C
CVC
CVCVC
CVCVCVC

etc., i.e. alternating consonants and vowels beginning and ending
with a consonant.  In this system, all morpheme boundaries are
marked by consonant clusters, and every consonant cluster marks
a morpheme boundary.  For example, _blaraktalmin_ can only be
segmented as b-larak-tal-min.  If every word has to begin with
two consonants in a row (i.e., with a C morpheme), word-level
self-segregation is also achieved.

> But when I look at (b) I have some reservations. In the section headed
> 'Example" Jeff begins: "Let's build a toy language using this syntax."
> But the examples given are IMO just relexifications of English, cf.:
> Gl tkn  jl.
> I  like you.
> 
> Ckl tkn   gl.
> She likes me.
> 
> Gl mgn   hbn ccl.
>   I drive the car.
> 
> Gl mgn   ckn ccl.
>   I drive her car.
> 
> Gl cnn mgn  bn ccl.
>   I can drive a car.
> 
> Gl tks  ckl mgn     gn ccl.
>   I like her driving my car.
> 
> Gl mln  mgn   gn ccl thn jl.
> I  will drive my car to  you.
> 
> The word order, use of a future auxiliary and of definite & indefinite
> articles is 100% English.

Yes.  That is relexified English and not a loglang.  It is hardly
even a briefscript, because Jeff's words aren't much shorter than
their English countrparts (some are even longer).

If I was to design a loglang, I'd use a "P X1 X2 ..." syntax, wherein
P is the predicate and X1, X2, etc. its arguments.

> Another point that I question is his use a 'precedence grammar'. He
> rightly says "Humans are not very good at dealing with parentheses, as
> any Lisp programmer can attest!"

Yes.  I don't program in Lisp, but the same kind of problem occurs
in C and its descendants (or for that matter, in any block-structured
language, only the shape of the delimiters - `{' and `}' in C,
`BEGIN' and `END' in Pascal, etc. - varies), so I know that problem
rather well.  Hence, I not only indent blocks consistently in my
programs, but also add comments after every `}' to indicate what
it closes, e.g.

  while (x>0){
    y=depth[x];
    while (y>0){
      a[x][y]=x*256+y;
      y--;
    } /* while (y>0) */
    x--;
  } /* while (x>0) */
    
>        but I have reservations about his
> method of dealing with this. The word final affixes 'l' and 'v' (and
> others) denote the precedence for each word, thus:
> 
>      bl cln dl bdv gl  ==  (bl cln dl) bdv gl
> but
>      bl clv dl bdl gl  ==  bl clv (dl bdl gl)
> 
> just as
>      a  *   b   +  c   ==  (a  *   b)  +   c
> 
> but
>      a  +   b   *  c   ==  a   +  (b   *   c)
> 
> Umm - but that is only a problem if we use an inorder tree traversal.
> Postorder & preorder traversals produce unambiguous strings without the
> need for precedence.

Yes.  It is an entirely unnecessary kludge, a consequence of a bad
choice of word order.  The SVO word order of English is just not
well-suited for a loglang.

>       Thus:
> 
> 1.the above four strings produced by preorder traversal (prefix notation):
> bd cl b d g
> cl b bd d g
> + * a b c
> + a * b c
> 
> 2.the above four strings produced by postorder traversal (postfix notation):
> b d cl g bd
> b d g bd cl
> a b * c +
> a b c * +
> 
> (The examples use white space as separators. In Jeff's languages white
> space should not be needed, but we will need some way of marking word
> boundary. Jeff does this by combining word-boundary _and_ precedence.)
> 
> The prefix forms are more reminiscent of Loglan/ Lojban word order. But
> Jeff does not consider either possibility, either of which would not
> require a precedence grammar. So why does he keep infix order, which
> necessitates a precedence grammar? The answer seems to me to be 'so that
> we can retain the English word order' (tho this is not explicitly stated).

Yes.  Jeff's self-segregation system rocks, but the clause syntax
is just as smelly as his phonology.

> What Jeff seems to me to have done is to provide a way whereby one may
> analyze an English sentence as a binary tree and then generate an
> continuous stream of characters (alphabetic, bits or whatever) which
> both maintains the same word order as English and unambiguously
> represents that tree. Ingenious - but a wee bit anglocentric, methinks.

Yes.  Anglocentric is the right word.

> But maybe if I consider postfix or prefix order......

Go for it!

Greetings,

Jörg.