Path: utzoo!utgpu!news-server.csri.toronto.edu!rutgers!cs.utexas.edu!uunet!cs.dal.ca!ug.cs.dal.ca!chris
From: chris@ug.cs.dal.ca (Chris Robertson)
Newsgroups: comp.ai
Subject: Re: Toward an Emotional Computer
Summary: same work to do, "connections" or not
Keywords: algorithms, representation, implementation, complexity
Message-ID: <1990Dec30.175326.2309@cs.dal.ca>
Date: 30 Dec 90 17:53:26 GMT
References: <28884@usc> <MITCHELL.90Dec17113059@gluttony.uchicago.edu> <37025@cup.portal.com>
Sender: news@cs.dal.ca (USENET News)
Organization: Math, Stats & CS, Dalhousie University, Halifax, NS, Canada
Lines: 43
Nntp-Posting-Host: ug.cs.dal.ca

In article <37025@cup.portal.com> PLai@cup.portal.com (Patrick L Faith) writes:

> well the problem is this ... how do you effect a group of nodes without
> having connections to them. i.e. lets say one node should effect 10000
> nodes, it is a major waist of resources to have that one node connected
> to each of the effected 10000 nodes.  So instead you have non-linear 
> connections (i.e. not point to point ... or node to node) that effect a
> certain type of nodes, or nearby nodes ... etc... 

OK, so you take the "linear connections" out of the MODEL we use to build
the program.  So let's see, node X has to be involved in the determinations
of a whole whack of nodes, say { a1, a2, a3 ... a999, a1000 }.

Previously maybe we would keep a list like { <X,a1> <X,a2> .. <X,a1000> } to
tell us all of the "connections" outgoing from X, or perhaps the other way
with each node having a list of INcoming connections, either way it doesn't
matter.

So now, if i take you correctly, we just make sure that all of {a1..a1000}
can be picked out by the propogation algorithm as belonging to a unique
group, lets call it the "a" group.  Then we, instead of the linked list
mess above, we can just say "X is connected to a*" (however we happen to
represent that).  So now we have saved resources, right?

But as much work must still be done in the PROPOGATION itself, regardless
of perhaps a little space saving in the representation.  Also, instead of
having just a list of internal pointers through which to loop, now we must
search all the nodes to see if it is in the "group" currently being
stimulated.  Even with an index, or storing nodes in a tree, that's still
an increasing time complexity, which we STILL must multiply by the number
of nodes in the group anyway .. so its a little slower, but probably
saves on RAM a bit.

Of course, the slight extra time toll could be worth it for thebetter
expressive power of the code.  I'm sure someone out there has a simulator
which lets you define predicates over the node space, then propogate
signals according to the truth of logical sentences constructed from them.

That would be neat to see.  Anybody out there ever seen or written a package
like that?


| sig > /dev/null    ;^)    chris@ug.cs.dal.ca