Ops are defined as
1. Transformations of the form:

operation registerX registerY registerResultZ registerResultZFalse (optional)

2. Lookups|References|Projections
that involve in some form, copying data from one place to another
operation nodeId registerX, store at: nodeId registerY

3. Processes & Logic
think 'slices' of lists, loops, jumps, etc.


notes:

as outputs are sent to node id's, visually we build up stronger and
thicker, and less transparent lines between those nodes.

inputting a list to an operation, operates over the entire list, and
appends it to register Y as a result


when doing a comparison involving at least one list,
an operation has to be specified for that list, be it
len(), max(), min(), mean(), head(), tail(), slice(), etc.

a register may store a node id to jump to in order to
do indirection.  this is how branching is handled.

operation                   opcode
if greater than             ifgrt
if greater or equal than    grteq
if not equal                noteq
if less than                iflss
if less than or equal       lsseq
if equal                    ifeql
if within range exclusive   wrnex
if within range inclusive   wrnin
if negative                 ifneg
if positive                 ifpos
get length                  gtlen #for a list, returns the length, for a string, returns length, for a number returns whole digits


we can develop functions for normalizing to a range


the register values are broken into
register_index OptValueOrOperation (slice index, max, mean, min, %, head, tail, null/treatAstype)

For null, what the system does is infers the type.
If its a list, it by default gets the defaultListOp of the node (get the max, mean, or head)
if its a node id, the optvalue is a register index for that node, which in turn returns the register value).

Connections are drawn between nodes using if statements that have nodeIds as their register results.
r0 is always used for the result of the last operation before a jump. So
a code line like "ifgrt r5 r1 r6" where r6 is some other node, would first lookup r6.r0, set it to
the result of "ifgrt r5 r1" and then jump to r6.

We could teach the system to make trees, or test it against correctly predicting standard loss
functions given some input, or even teach it to do convolutions.
All we would need is
1. training data
2. test data
3. validation data

And let it find the code or function, through combinatronics, that does it for us.
Prune any nodes that don't get used, package it into a supernode, and let other nodes
refer to it.