Absolutely Dynamic System

== What is this ADS-AC like? ==

=== Structure ===

It consists of TWO parts: links and nodes.

Links can be thought as roads, highways, axiomas, wires, what ever.

Nodes are places where two or more links meet, like at a crossroad or a knot of strings. A node can be either "new" or "old" in time.

=== Terms and concepts ===

A "neighbour node" is a knot (B) that knot (A) directly connects to, i.e. they share a link.

A "common node" is a node (C) to which both A and B have a direct connection / link to, e.g. when some A's neightbour node is also B's neighbour node, then this node C is A's and B's "common node".

=== Now how does the system work? ===

=== In the beginning there was... ===

The very initial situation is a pre-build (hand made, with some algorithm or just randomly spawned, how ever you want) set of nodes and links, where  all or just some of the nodes are marked as "new". Usually the initial sets aren't very complicated or large, but that depends your personal preferences.

For example, there might be 24 nodes that are all randomly linked to 8 other nodes and 12 of these 24 nodes would be set as "new", the rest would be "old" nodes. This would give us a nice, messy initial situation.

=== What next? ===

Next we process all nodes that are marked as "new". The idea is to do it simultaneously, but it doesn't matter if we process them one at a time as the end result stays the same.

So what we do for each "new" node (A) is to loop through all it's neighbour nodes and for each neighbour node (Bn) that shares a common node (Cn) with A we create a new node (D) and link it with every A's and B's neighbour node that is NOT common to A and Bn.
Maybe some pseudo-code would make more sense at the moment:
<pre>
for (every new node (A) that was created last turn) 
    for (every node (B) that A is linked with)
	if (A and B both are linked to a common node (C) 
        that's not either A or B)
	{
	    Create new node (D)
	    Link D with all A's neighbour nodes that 
		are NOT common to A and B
	    Link D with all B's neighbour nodes that 
		are NOT common to A and B
	}
	else
	{
		Delete B
	}
</pre>

=== It's alive, it's alive! ===

ADS is cabable of learning. It has been taught to play a game of Nim (a game where you have three separate towers of tiles and in your turn you may remove any number of tiles from a single tower. The player who removes the last tile loses.), and this process took about three months of seamless learning on a 1,5GhZ system, but there are no clear results yet. It is clearly shown though that it is capable of learning by a test (can be downloaded together with the source code), where it was trained to repeat a word.

=== Training ===

The system supposed to learn based on the principle coming from the theory, that it tries to act so, that it can predict the results of its behaviour. It is possible to write a training program for it, in C, as a plugin. The training program acts in a certain way to its certain outputs. These funtions of the training program provide for a system the "toys", it plays with.

A training program trains the ADS like this:

1) The training program activates some node(s) (An). The activated nodes can be selected by any means, e.g. randomly or with some predefined order, one or twenty at once. The node(s) thus become(s) "new" and it's/they're fed with some input that it/they store. 

2) The node net (ADS) is now processed: all new nodes spawn yet new nodes as explained above.

3) The training program checks all the i/o nodes. If a new node has been spawned (by ANY reason/other node) and linked to the i/o node as a neighbour, the i/o node becomes old and the i/o node's input is returned unchanged as it's output.

The training program also usually calculates a statistics, of how well the system performs, and writes it to a text file.

=== Learning ===

The learning is basically just nodes being born, old nodes dying away. Dying of nodes happen the following ways:

1) The system notices that it has grown too large, so it finds a deletable node (how this happens depends on the implementation details) and removes it from the network.

2) All nodes have a decay counter that's increased each cycle. If the counter exeeds some pre-defined limit, the node is too old and decays away, i.e. is removed from the network.

When the ADS has finally "learnt" something, it has simply achieved a state where, when a new node gets born, the structure doesn't really change anymore.

=== An example implementation ===

Everything consists of links of the same
type. Node consists of first link, which connects it
to certain chain, and following double-linked list of links,
of which everyone points to one other node. There are three
chains, newchain (for new nodes), oldchain (for old nodes)
and freechain. By these chains, a kind of real-time engine
is implemented, these determine the order of processing,
somewhat like the event chains in Unix kernel. In every cycle,
the first node in the freechain shall be processed. Freechain
is just a linked list of deleted links, when deleting the node,
it shall first be linked off from its chain, and then all its
links would simply be put in the end of the freechain. Of course
when we create a node, all links necessary for it would be taken
from the beginning of freechain.  So freechain is a kind of
"garbage collector" for links.<br><br>