# tunes-0.0.1.c

Tril dem@tunes.org
Mon, 30 Nov 1998 13:42:38 -0800 (PST)

```On Mon, 23 Nov 1998, RE01 Rice Brian T. EM2 wrote:
> i'd like to start with the idea of constructing worlds from graphs
> (multi-graphs and such), and allowing 'higher-order' statements to be
> made via arrows whose nodes may be arrows or groups of arrows, instead
> of necessarily indescribable atoms.  this is intended as the mechanism
> for knowledge-level reflection in the base system (that system where the
> context is constant).  i'm not sure how to implement inifinitary shapes
> of arrows in a way which does not violate the simplicity of the
> data-structure format, while still allowing a simple axiomatic
> 'machine-model' definition as we have discussed.

I like the approach of arrows.  A graphical approach should work.

How will you define the semantics of an individual arrow?  In terms of
other arrows, I assume?  You will have unlimited levels of nesting of
"arrow spaces"?  If you don't know what I mean, please ask and I will
clarify.

The only way I know to represent infinity is by recursive functions (in
your case, an arrow, where the space defining the meaning of the arrow
contains a reference to the first arrow).  You can define infinity by an
iterator function, that produces N arrows in a pattern, where the given N
required by the function must be finite, but the *type* of N is boundless.
Does this make sense?  This description was also very brief, and can be
expanded if you need examples.

> changed, possibly permanently, within the last day or so.

If you want to have a dialectic then I'm game.  I'll try to keep up with
you!

[Stuff snipped because I either agree or am waiting a response on my
semantics question.]

> btw, if anyone knows of a better interface for maintaining object
> references in the system i am describing other than by explicit pointers
> (or just as complicatedly, by graphical-arrow representation), then
> please share the idea, since my system as it stands will require lots of
> searches or lots or reference-counters for a garbage-collector.

The question shouldn't be "is there a system to maintain object references
dynamically."  The question is, "does the complexity of the system I am
developing make up for itself in the expressivity gained?"  The idea is an
extraordinarily complex system will make up for its own complexity, if it
is reflective.  (i.e. the complexity can be used to index itself.)
In other words does YOUR system of arrows and nodes provide sufficient
expressivity to support the functionality it needs (maintaining object
references).  If so, then you're set because as long as your system is
reflective it can use its own features to implement itself.  That's just
my theory.  It's not supposed to be easy to DO.  ;)

David Manifold <dem@tunes.org>
This message is placed in the public domain.

```