Re: [lojban] &Lang

[And Rosta <and.rosta@gmail.com>]

.arpis., On 13/07/2012 19:05:
> On Fri, Jul 13, 2012 at 10:31 AM, And Rosta <and.rosta@gmail.com <mailto:and.rosta@gmail.com>> wrote:
>     An example (without wanting to be distracted by irrelevant details):
>
>     "Da djuno lo du'u de prami da gi'e de nelci da"
>     djuno(da, &(prami(de, da), nelci(de, da)))
>
>     Task 1: notate this (linearly) so that "da" and "de" each appear only once.
>
>     And then:
>
>     Task 2: Improve the system so that speakers don't have to hold in memory the arbitrary correspondence between variable & phonological form.
>
>     Will De Bruijn indices deal with Task 1? If they do, I'd be thrilled to have learnt summat new.
>
>
> Ah... No. De Bruijn indices do nothing about factoring out common use sites. You might want to look into the SKI (or SK) calculus; it is capable of expressing everything that the lambda calculus is.
>
> What you really want is to define a predicate out of djuno, du'u, prami, and nelci that has the right meaning and never use "da" or "de" at all, because if they appear only once and in obvious positions, they are superfluous.
>
> Here's how I would go about deriving such a predicate, in case it helps:
>
> Recognize that \ko'a. \ko'e. gi'e (prami ko'a ko'e) (nelci ko'a ko'e) is a useful abstraction
> This abstraction can be generalized to
> \conn. \b1. \b2. \ko'a. \ko'e. conn (b1 ko'a ko'e) (b2 ko'a ko'e) which reduces to SK as follows
> \conn. \b1. \b2. \ko'a. \ko'e. (conn (b1 ko'a ko'e))                                 (b2 ko'a ko'e)
> \conn. \b1. \b2. \ko'a. S (\ko'e. conn (b1 ko'a ko'e))                   (\ko'e. (b2 ko'a) ko'e)
> \conn. \b1. \b2. \ko'a. S (S (\ko'e. conn) (\ko'e. (b1 ko'a) ko'e))            (b2 ko'a)
> \conn. \b1. \b2. \ko'a. S (S (K conn) (b1 ko'a))                                     (b2 ko'a)
>
> \conn. \b1. \b2. \ko'a. (S (S (K conn) (b1 ko'a)))                              (b2 ko'a)
> \conn. \b1. \b2. S (\ko'a. S (S (K conn) (b1 ko'a)))                 (\ko'a. b2 ko'a)
> \conn. \b1. \b2. S (S (\ko'a. S) (\ko'a. S (K conn) (b1 ko'a)))            b2
> \conn. \b1. \b2. S (S S (S (\ko'a. S (K conn)) (\ko'a. b1 ko'a)))         b2
> \conn. \b1. \b2. S (S S (S (S (\ko'a. S) (\ko'a. K conn)) b1))             b2
> \conn. \b1. \b2. S (S S S S S (K conn) b1) b2
>
> And now I'm bored, but I think that this was illustrative.

Either I've misunderstood your response, or you've misunderstood the challenge. The challenge is that the same bound variable need never be repeated. Sure for any given single sentence containing n different variables you can define an equivalent single predicate with n arguments, but you can't do this for each of the infinitely many sentences in a language.

> Other things you may want to look at: combinatory logic,
> concatenative programming (or stack-based programming), point-free
> style (or tacit programming), and the J programming language.

Thanks for taking the trouble to make the suggestions, but I don't have the requisite intellectual skills to scan outlines of those areas in the hope of descrying a notation that doesn't require variable repetition. If you think one of them provides a notation that doesn't require variable repetition, it would be very precious to meif you were to explain it to me.

--and.

--
You received this message because you are subscribed to the Google Groups "lojban" group.
To post to this group, send email to lojban@googlegroups.com.
To unsubscribe from this group, send email to lojban+unsubscribe@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/lojban?hl=en.