Concise notation for event-token reification
martinobal
I'm trying to find a concise form of event-token reification (as
described by Donald Davidson).
I'm using types to avoid the need for parens. All functions have fixed
arity and the only brackets left are those marking beginning and
ending of blocks (kind of lists. I'm using some of REBOL terminology,
because the syntax ends up looking much like REBOL, that is, Polish
notation). Even those can be reduced, by only having the block end
marker. For those rare cases where a block is passed by name instead
of explicitly, a keyword overrides this behavior.
[DISCLAMER: I don't claim to have a deep knowledge of type theory,
logic and other stuff I may mention. I'm just playing with the idea of
making an expressive logical language based of event-token-reification
(ETR), among other things. There may be big beginner mistakes in my
ideas and I'm looking for help.]
What we want to express is a sentence like this:
"Brutus killed the emperor with a knife"
If we use ETR it may be something like this:
(exists (?e) (and (eventOfType kills ?e)(subj Brutus ?e) (obj (the
emperor) e) ((a-role w-instr knife)e) ))
Where:
(def a-role (lambda (?r ?p ?a) (exists (x) (and (?r ?x ?a)(exists
(e2) (and (eventOfType ?p ?e2)(subj ?x ?e2)) ))) ))
So, these are my types:
o: object (individual)
v: truth value (T|F)
b: block
Now let's declare the types of some symbols:
declare L#kills [a] :: b->v
declare kills [a b] :: o->o->v
declare longsnt [p] :: (o->o->v)->(o->o->b->v)
declare knife [a] :: o->v
declare emperor [ a]:: o->v
declare Brutus [ ]:: o
declare subj [a b] :: o->o->v
declare obj [a b] :: o->o->v
declare w-instr [a b] :: o->o->v
declare the [p] :: (o->v)->o
declare a-role [r p] :: (o->o->v)->(o->v)->o->v
Notes:
_We assume implicit currying of all functions.
_the "L#" version of a verb is the long version, which takes a block
and gives a truth value.
the sorter version has, by convention, the same name minus the "L#".
The short version is declared from de long one.
The short version only takes the arguments for subject and object
(which lets us ommit "subj" and "obj" in the sentence), and it
doesn't take a block, where the additional thematic roles would be, so
it lets us ommit the block ending mark ("end") but this makes it less
expressive than the "#L" form. That's why we also define a
"longsnt" (long sentence) function, which takes the "kills" function
and returns a function that does accept a block for additional roles.
L#kills obj the emperor subj Brutus a-role w-instr knife end
_parsing: (L#kills [obj the emperor subj Brutus a-role w-instr
knife] )
kills the emperor Brutus
_parsing: (kills (the emperor) Brutus)
longsnt kills the emperor Brutus a-role w-instr knife end
_parsing: ( (longsnt kills) (the emperor) Brutus [a-role w-instr
knife] )
The types let us get rid of most brackets, but we need fixed arity
functions, and we use blocks (lists, tuples,..) for things with
variable number of items. The evaluation is Polish notation, much like
in REBOL. Since we use lots of lists, we ommit the beginning of the
list and only write "end" at the end of the block. There's a "noblk"
keyword that lets us pass a value as a list instead of writing down
the list. There's also a "bgnblk" keyword to be used in combination
with that. For instance:
declare exampleBlock :: b
def exampleBlock obj the emperor subj Brutus a-role w-instr knife end
OR:
def exampleBlock noblk bgnblk obj the emperor subj Brutus a-role w-
instr knife end
And then we can use it:
L#kills noblk exampleBlock
Now my question is:
I need a function to take a block and return another block where the
items have been recursively wrapped in inner blocks according to their
types, so that the return block is made of blocks, and each of these
inner blocks, when applied, is of type o->v. Let's call this function
"smartReduce", for similarity with REBOL's "reduce".
For instance (using "_#" for user imput and "_>" for the
interpreter's output):
_# smartReduce [obj the emperor subj Brutus a-role w-instr knife]
_> [ [obj the emperor] [subj Brutus] [a-role w-instr knife] ]
_# def exampleBlock [ obj the emperor subj Brutus a-role w-instr
knife ]
_>
_# map [tail-block-concat [e]] exampleBlock
_>[ [obj the emperor e] [subj Brutus e] [a-role w-instr knife e] ]
Well, you get the idea.
Any help and/or feedback appreciated! :)
martinobal
> Hi,
>
> I'm trying to find a concise form of event-token reification (as
> described by Donald Davidson).
A little correction:
Sorry, I forgot to say that I want to treat "emperor" and "knife" as
states, which can begin and end, and have a subject, so much of what
applies to "kills" and "L#kills" applies to them. To avoid confusion,
I'll declare the predicates "L#isAnEmperor" and "L#isAKnife", and then
their short forms.
declare L#isAnEmperor [ a]:: b->v
declare isAnEmperor [ a]:: o->v
declare L#isAKnife [a] :: b->v
declare isAKnife [a] :: o->v
L#kills obj the isAnEmperor subj Brutus a-role w-instr isAKnife end
_parsing: (L#kills [obj the isAnEmperor subj Brutus a-role w-instr
isAknife] )
kills the isAnEmperor Brutus
_parsing: (kills (the isAnEmperor) Brutus)
longsnt kills the isAnEmperor Brutus a-role w-instr isAKnife end
_parsing: ( (longsnt kills) (the isAnEmperor) Brutus [a-role w-instr
isAKnife] )
---
Now we can say: "Brutus killed the then-emperor with a knife":
L#kills lam-x obj the lam-x L#isAnEmperor subj x time-1* super-x end
subj Brutus a-role w-instr isAKnife end
---
lam-x means "lambda (x)". This way we avoid having to name a variable.
We win concision.
"super-x" refers the "x" in the next outer closure. That's a way to
avoid name collisions in nested lambda expressions. The "super-x"
would have a dedicated short word. Notice that the outer lam-x is of
type o->v as required.
time-1*: The "1" means that the beginning of the L#isAnEmperor event
is in the position "1" with respect to the L#kills event, and the "*"
means that we don't care about the relative position of the ending of
the L#isAnEmperor event,that is:
"time-1* L#kills-event L#isAnEmperor-event"
For instance, if we have two events, A and B, and the sequence is
"begin-A begin-B end-B end-A", then we say "time-15 B A". The range of
1 to 5 is due to the fact that intervals have two points, so, begin-A
could be before begin-B (1), coinciding with begin-B (2), inside B
(3), coinciding with end-B (4) or after B (5). In the conlang
implementation "time-15" would be three short words, or maybe just
one.
For this kind of situation, instead of the nested lambdas we can
define a function "the-when-role", so that in this case we would say:
L#kills the-when-role time-1* obj isAnEmperor subj Brutus a-role w-
instr isAKnife end
We can also define an "a-when-role"
L#kills the-when-role time-1* obj isAnEmperor a-when-role time-*1 subj
isTrustedByCaesar a-role w-instr isAKnife end
I hope it looks better now :)
Paul Bartlett
> Hi,
>
> I'm trying to find a concise form of event-token reification (as
> described by Donald Davidson).
> I'm using types to avoid the need for parens. All functions have fixed
> arity and the only brackets left are those marking beginning and
> ending of blocks (kind of lists. I'm using some of REBOL terminology,
> because the syntax ends up looking much like REBOL, that is, Polish
> notation). Even those can be reduced, by only having the block end
> marker. For those rare cases where a block is passed by name instead
> of explicitly, a keyword overrides this behavior.
> [...]
You may have a wrong newsgroup. This newsgroup is about artificial
languages in the manner of constructed international auxiliary
languages such as Esperanto, Ido, Interlingua, Sona, and so on, as well
as constructed or artificial languages that people may build for humans
or humanoid creatures in fictional worlds, such as J.R.R. Tolkien's
languages for his fictional worlds (Elvish, Mannish, and the like in
"The Hobbit" and "The Lord of the Rings"), or as hobbies).
--
Paul Bartlett
martinobal
Hi, Paul
I see, but aren't so-called "logical languages" like Loglan and Lojban
included in this category? They are what is often called
"engelangs" (engineered languages), which also includes most IALs.
I'm having problems to decide where to post my question, and cross-
posting is often frown-upon, isn't it?
I've thought about posting to comp.lang.functional , comp.ai.nat-
lang , sci.logic , fa.analytic-philosophy or comp.ai.philosophy , and
the subject is somewhat related to all of them, I think, but not quite
to any of them :/
Do you recomend some specific group for this thread?
Thanks for the information, anyway.
Rick Harrison
<7bd91144-85f1-4b7c...@m45g2000hsb.googlegroups.com>,
martinobal <marti...@gmail.com> wrote:
> Hi,
>
> I'm trying to find a concise form of event-token reification (as
> described by Donald Davidson).
A very small percentage of language inventors are into this style of
language -- your best chance of finding a like-minded person would be
to post in one of the more highly populated forums. One of them is
http://www.spinnoff.com/zbb/ (the ZBB)
You might also find a like-minded person in one of the Lojban or Loglan
forums.