The Causal Ligature class is the meat and potatoes of
InformationSpace. It is here where all of the heavy lifting is done
for explorations. The Causal Ligature is exactly what it implies. It
is the class that embodies the causal rules that exist between the
bits in a particular information space. The Causal Ligature class
itself is intended to be an abstract class that is sub classed for
each different type of causal ligature that the user wishes to implement.
An Information Space is a collection of causal bits. Each bit has 2
primary pieces of information; location and state. Location is the
position of the bit in the space; IE it's X,Y,Z coords (Or X,Y for a
2D space). It's state is either on or off (True or False). The Causal
Bit class embodies this information in the Smalltalk system.
Causal Ligature operates on causal bits by first connecting them into
a rubix cube style arrangement (Or into a planar 2D arrangement of
3 X 3 bits for 2D spaces). This connecting is done via the messages
linkUpRootBit: and addNeighborBit:atTheta:Radius:polarZ:. The first
step is to set up the root bit (Center bit) for this run, then add its
neighbors. The neighbors are referenced using polar coordinates
relative to each of the 3 planes in the Z (for 3D) or the 1 plane in
2D. For example, in a 3D space, there are 3 planes: -1, 0, 1. 0 is the
plane in which the root bit lies. In the -1 and 1 planes there are 9
neighbor bits each. 8 at radius 1, omega 0 to 315(45 degree increments)
and 1 at radius 0 with no omega specified. In plane 0, there are 8
neighbor bits at radius 1, omega 0 to 315 (in 45 degree increments),
and the root bit at radius 0.
Once the bits are connected into the data structure the
getNextGeneration: message is sent with the current generation number
specified. This is an important distinction to note. The user sends
the message with the current generation, not the generation to be
calculated. For example, after connecting all the bits together as
noted above, the user would send getNextGeneration:1 (Assuming this is
the beginning of the exploration). This tells the Causal Ligature to
find the bit state for the second generation. The bit state in
question is the state of the root bit.
This process is repeated for all of the bits in an information space.
After each complete pass, the current generation marker must be updated
and the whole process is repeated for the next generation.
As it stands, this process is computationally expensive, there is a
significant amount of message passing being done. The goal is to get a
complete, correct implementation and then to perform the optimization
on it. This implementation is still in progress and once complete may
be either profiled for optimization or ported to a higher speed
language such as C.