Message-Id: <199601130145.UAA25208@locke.ccil.org>
Date:         Fri, 12 Jan 1996 22:42:36 GMT
Reply-To: ia@stryx.demon.co.uk
Sender: Lojban list <LOJBAN@CUVMB.BITNET>
From: Iain Alexander <ia@stryx.demon.co.uk>
Subject:      Re: opaque
To:         lojban@cuvmb.cc.columbia.edu
Status: OR
Content-Length: 4360

In message <821300856.195.0@cunyvm.cuny.edu> pcliffje@CRL.COM writes:
> i,n:
> Sure, you can define lexical items that way, but I reckon what
> you end up with is no longer a predicate - it's some other
> kind of operator,  one whose arguments cannot be fully
> interpreted (as referring to anything), but must
> be treated in some other fashion.  (The traditional solution
> for this is treat arguments as text, but I can conceive that
> there might be su'o intermediate solution.)
> Lojban gismu are "sold" as predicate words, and I've assumed
> that the same applies to other selbri in general.  I could
> accept other kinds of "lexical item" in the language, but I
> would much prefer them to be clearly marked as such.
> pc:
> They are still predicates, because Lojban (and languages
> generally) are type-theoretically flat.  The critters that go into
> those slots are either perfectly normal but evaluated oddly or odd
> things evaluated perfectly normally -- for the sorts of things they
> are, take your pick.

I'm saying that if any of the arguments has to be evaluated oddly,
the operator is not what I think of as a predicate.

> Generally,  I have gone along with normal
> things evaluated oddly, since that seems easiest to work with
> ontologically (I don't much like transworld objects in my object
> language), but the other makes some other things easier to do, at
> first glance anyhow.  Taking the odd things as texts --

No, I meant taking the _normal_ things as texts, one way of
evaluating them oddly.

> unless you
> mean something novelly subtle by that -- is an idea that tends (on
> the half-dozen occasions it has been suggested in 2500 years) to
> die in the worst ways in about a week of scrutiny; in what
> tradition has it hung on?

The Computing Tradition.  %~}
In many computer languages, arguments are normally evaluated before
invoking the function.  But for situations where this is not
desired, there is some mechanism to prevent the evaluation taking
place, which usually involves treating the argument in some sense,
explicitly or implicitly, as text.

> i,n:
> As for pictures, I think that what is depicted is some sort of
> abstraction (in the most general sense) of/from the object in
> question, which might be appropriately represented by a Lojban
> abstraction (NU), but again probably not involving {lo broda}.
> pc:
> _lo broda_ has to get in somewhere if it is a picture of  a(some)
> broda(s).

I dispute that it can be a picture of a(some) broda(s) unless
there is a(some) broda(s) of which it is a picture.  I suggest
that it is "really" a picture of something-to-do-with-brodas
(and I would like to be much more specific than that, but I
don't have all the answers :-).

> pc:
> _ce'u broda_ is just _broda_ and so _tu'a ce'u broda_ is ill-formed,
> _tu'a_ requiring a sumti. The lambda paper sometimes talks as
> though \xFx were a sumti but, in fact, it is whatever F is, here a
> predicate). _lo ka ce'u da broda_ is not \x: x broda, but
> ^\x:x broda, not the predicate "is a broda" but the property of
> being a broda, brodatude.

I regret that {tu'a ce'u broda} was particularly poorly conceived.
It should have been {lo su'u broda}.

But as an aside, I believe Cowan's intention was that {ce'u broda}
be an abbreviation for {ce'u da poi broda}, which is at least a
pseudo-sumti, which if placed in an appropriate context produces
an expression which can be expanded to a well-formed formula.
(You may of course question whether it actually means anything,
but that's a separate matter.)

> Neither of these (_broda_, however
> disguised, nor brodatude) seem to have any obvious help in this
> area (each has a place in another, often related, problem), but
> events (or whatever you want to call 'em) do seem to help a bit.

My instinct is that any abstraction involving a single
distinguished entity can be derived by applying a suitable
operator to an appropriate lambda expression.  (I'm thinking
about the set {x: broda(x)}, the quantifications
(Qx: broda(x)) (where Q is any quantifier), the number
of x which broda, the unique x which brodas, etc.)
However, I've not idea whether this is in any sense provable,
and I'm certainly not in any position to attempt it at the moment.

--
Iain Alexander                    ia@stryx.demon.co.uk
                    I.Alexander@bra0125.wins.icl.co.uk