User:Jack

• Project document for Human consumption
  • The two domains   (Fourier transforms, energy and matter)
  • Relative Traversal   (List-Space)
  • key-as-hashref   (What does it mean conceptually to use a hash-ref as a hash-key?)
  • Nodal-space vs List-space(Node-Space))
• xhtml.jpg
• Jack/Todo

1. Binary

I was thinking that a good foundation for a lot of other discussion is the concept of binary in general. Binary is the simplest form of distinction, and the bit is the most fundamental unit of information. Binary and is not only made of two states, or symbols, but also gives rise to two different ways when considering sets of bits. These two basic ways are the root of the two domains.

• Names: The using of the binary sequence simply as being distinct from all other sequences. In the nodal model, traversal is used to assign distinct sequences to a particular piece of information.
• Number: A simple geometric which compliments traversal gives rise to ordered sequence, and using recursion is infinetly divisable. Ie a discrete process which forms a continuum. In the nodal model, the geometry is based on this method - recursively dividing a window or period.

1. Nodes & Associations

• an association is a typed-relationship between its container and another node

So there are three nodes involved here, the container, the other and the type

• each node contains only associations - it is a set of class:instance associations

I've used the word set instead of list here, because its by traversal that you get to them, there's no full list of them

Although class:instance associations are analageous to key:value pairs in associative-arrays, they are not name-based, and you can't iterate through a list of them all

• In each node, there are four fundamental associations, prev/next and parent/current

prev/next and parent/current (they can be called axes, horizontal and vertical)

These four are common to all because they are the concepts used by reduction which defines the fundamental functionality of node-space.

• The prev/next associations form loops, and all the nodes in a loop are called siblings.

The loops contain a subset of the nodes associations, and can be iterated through because they're linked lists

All the associations within a node are its 'potential content/structure, and those in the loop are actual

• Nodal methods are create/delete/get/set association, and reduction

// instance.create/delete(class) calls class.create/delete(instance) // create inserts the instance into the classes instance-loop (list-aspect, next/prev) // ie. our list of current children (that our E divides amongst) is also our instance-loop // has or is are one, they're all just relationships that receive a portion of energy // laster: a chain of delegate classes is created between root and the instance // - the class of any assoc requires a portion of the quanta // remember, next/prev and complimented by parent/current (parent is also class) // - this allows alternate quanta be divided between parent and current, thus providing // energy for the class->instance relationship // - get retreives from class value if no instance value at each step of a path

1. REDUCTION

• Reduction starts at root, every iteration of reduction involves one quanta being sent to root

The root-node is also the first list-space item

root has an actual-loop just like all other nodes which rotates like normal each quanta

the root is all the high-level information and processes this peer supports or cares about

Like any other node, root contains potential-content, but in the special case of root, the potential content is every node this peer knows about. Also because its the root context, traversal is not necessary to reach those nodes - the direct reference, or address of the node is itself-within-the-context-of-root.

• Quanta poor in a rotate withinwards as per the dynamic diagram that doesn't exist yet
• When a quantum reaches a node exhibiting a local declaration, it executes it and that iteration of reduction is finished

As the quanta trickle down, rotation happens at every level regardless of whether or not execution occurred

Each quanta is really two, one for whole, one for part.

This is because when execution happens a second quantum is also sent to the class. This way all the non-actual associations in root also get quanta used for managing their many instances "in the field"

// - all instance-loops work by going cd this.current then assigning this.current.next to it // when a function executes, it can update the loop at that location (equiv to array.push) // - a functions parameters (and even further methods and tools) are child associations // the structures necessary to build the fucntion are child assocs too