Artificial intelligence, simulation, ant world, stock market (idea from 2003)
The World project is a model that is an abstraction of many other real models in the world.
The idea is simple: there is a world with defined locations, which can hold objects in them.
Instead of having the world control the objects, we allow the objects to interact with
each other. Thus, we don't have a world which needs to: check where every object is, check each
object's state, request a move, etc. The nodes in the world interact with each other, just
like objects in a nanotechnological world would interact with each other. The benefit to
having nodes do the work is that by using distributed computing, we can use multiple
processors do work instead of using one processor do all the work.
---------------------------------
Where could this model be used?
1) The Brain - The idea came from building a neural net, with the neurons interacting
with each other in a model that tries to replicate the physical world of the neural nets
(i.e. a copy of a brain).
2) Simulation - Another application that comes to mind is simulation. Each node can
represent an object in the physical world, holding specific data (attributes and functions),
and having different states, or requests.
3) Ant world - I have always wanted to create a simple ant world, where ants meet each other,
carry food, physically interact with the world. The idea was to have a plain surface which
is marked with squares, and then place an ant on this grid. The movement of the ant is never
straight, because ants have a genetically built-in method to walk, probably to search for
food their whole lives. If this movement were to be straight -> left -> right -> straight,
or some very complex movement, videotaping this move for the ant could allow to determine
this movement. A series of matrices could be built, showing the tendency of the ant's move.
If these matrices were accurate, the model should in theory predict the movement of an
ant to the highest accuracy. Please note that building an abstract behaviour model for an
ant would be much more computationally cheaper than building a neural net which acts
as a copy of an ant's brain.
4) Stock market - A possibly controversial but exciting application of this world is to
let each node be a specific stock, with attributes, certain behaviour, and so on. The
nodes are either let loose on the board (the world), where they interact with each other,
or they are linked ahead of time, if one knows which stock affects which other stock.
For example, a strong pharmaceutical company's stock could affect smaller pharmaceutical
companies' stocks, but not the stocks of a mining company. Stocks that are bonded together
would eventually find a stable location on the market world, slightly shaking in their
physical location, but no longer wandering off on the board. One option is to set the
nodes off, let them stabilize in the market world, and then dump real world data into
each node, and observe if they stay stabilized. One could use a year's worth of data,
and watch the nodes move into a new place, until stabilized. The actual prediction for
a current stock's rise or fall would be obtained after having a stabilized stock world,
and after dumping real time data into the nodes that are bound to it.
---------------------------------
Movement vector:
A node can also have a general movement vector, which is a weighted 3D vector which
generally tends to move into one direction. Even though the direction D=(x->, y->, z->)
has randomized values, these are added to a predefined static matrix, which makes
the direction more or less stable. The object crawls along the world, and when it reaches
an obstacle (i.e. end of the world, or another object), it acts according to the world
rules. It could bounce in an opposite direction, it could generate a new random movement
vector, it could act according to gravity.
---------------------------------
Creating the world:
The world can be created, and nodes can be randomly dropped into this world, and set alive.
Each node would move around in its own direction pattern. Once each node reaches another
node, it could make a bond with that node, enforcing a proximity with it, or it could
reject it, bouncing off in a haste, trying to get away from that node.
---------------------------------
A wrap-around world:
Instead of reaching the end of the world and bouncing off walls, a node could wrap around
the world, and when exiting on the right side, it would reappear on the left side. This
ensures that the physical world is just a container for the nodes, and that it would not
affect the behaviour of the nodes, which could be very sensible in nature.
---------------------------------
Bound nodes:
If two nodes which are meant to be together meet in the world, they create a link to each
other, and they try to keep this link alive and not broken. If one node pulls into one
direction and the other node pulls in an opposite direction, they must calculate which is
the dominant node, and compute a mean value, moving in that direction. The computation
can be a sumation of vectors. Note that we should not violate our object-oriented model,
and each node must compute it's own decided movement. We cannot have the world extract
the intended move for each node, and then compute each node's individual enforced move.
If node A has an intended move in direction vector a->, and it is only bound to another
node B, (but node B is bound to many other nodes which affect its move drastically), then
node A should only talk to node B, ask for its current intended move, and act upon it.
If B happens to be processing its move, and it needs a lot of time, this should not be
relevant to node A, who needs the information immediately and doesn't want to wait.
---------------------------------
How one moves:
Let A be a node that is not bound to any other node. Node A has a movement vector, which
tells it that it should pretty much move towards a predetermined direction. On each
iteration of the world (each "game move"), node A must do the following:
- talk to the world, give the world its current location, and ask if the next
physical location where it wants to move is available or not
- if the location is NOT available, probably because another node is currently
in the same spot, the world must give node A a link to the object which occupies
the location where node A wanted to move. This link is then used by node A to
decide whether the occupying node can interact with node A, or whether node A
should bounce away in a haste.
- if the location is available, the world must tell node A that the desired
location is available, and it must mark this spot as being occupied by node
A, and at the same time it must mark node A's previous position as being
free. Note that this move should be atomic, since we do not want node A
to exist in 2 places at once, and we also do not want two nodes to take
the same spot in the world.
- node A MUST then move to the new location.
Example of an atomic move. Semaphores must be used.
Node A's next intended move is to location N. Node B's next intended move is to location N.
Location N is vacant.
A -> World : "I want to move to location N. My position is X."
[World stores the request from node A in a queue]
B -> World : "I want to move to location N. My position is Y."
[World stores the request from node B in a queue]
World -> A : "Node A, checking location N... yes, it is avilable, ok, you can move
to location N. I have marked your current location X as being no longer
occupied. I will not talk with any other node (thereforer noone can
move to where you are, and step on you) until you have confirmed your
move. Waiting for your response..."
A -> World : "Ok, I have moved to location N. My new location is: N"
World -> A : "Thank you. Connection closed. Good bye."
World -> B : "Sorry for keeping you waiting, I am now available. Checking...
Sorry but location N is taken by ... checking ... node A. Here is
node A's reference, talk to it if you need to. Good bye."
---------------------------------
