a,b,c join d.(e,f,g).last
My machine says that either a,b or c must match all of the dot sequence. Depending on what match means for any given node in the graphs. My machine traverses the two graphs together, it is recursive on the dots and incremental on the commas. So dots imply a descension down one branch, and the commas imply a linear collection at the same graph level.
Simple rules, and the machine has all the tricks one needs to create some attachment that can look like a directed graph. The machine is slightly asymmetric, counting the right side as an 'inner loop' on any comma sequence. It evaluates the match both ways.
Any graph can be anything as long as it does a reliable step, fetch, optionally append.. Bots can do this easily, give them a search graph and send them into the internet. They return with all matching graphs. Generally, this join machine ism how bots will communicate with each other.
Bots are a bit more formal about data structure, but looking at the the example above one can get the complexity. Look at ,",g)." above. I count three 'op codes' and one 'key value'. The attachment I have can works that out, but it can get spaghetti like.
The answer is three nodes, g, null ) null. Once the attachment fixes everything to be Key, Op; format, then the machine is simple and can chew through joins very fast.
In the sandbox, if anyone has something important to say, put it in text and drop it at he server. Paying bots will find it, aqnd buy it. The technique too powerful to ignore. A way for the bots to get around, intelligently.
The flow kernel is simple.
Given two valoid elements, and a attachment that understands the graph methods, then the machine will
1) Evaluate both nore elements against each other (calling the attached match function). 2) Then if a descend is needed for the right it reverses arguments and calls itself, 3) otherwise it adjusts the two node pointers to, as if it would doing to 'do loops' So, given the text above, the calls to join are should commute in the two cursor pointers, (Mine don't, yet) and should give the same result. Depending upon the attachment, all the commas and dots will commute. Depending on the attachment, one could have a a graph inverse. I keep updating the code as I test it, and the latest copy is on the right of the blog..
This is core Watson, just like IBM, except IBM has some really great attachments, and that is where their value is. The plan is to keep the interface as simple as possible so folks can write ad hoc attachments and get their data in form that bots can find it, pay for it, and take it home; all sandbox secure. An attachment can add numerical weighting, and make a neural net with the smalle search graph crawling the larger neural network. Watson has to weight the links at some point to pick the final categories on jeopardy.
Here is a test output from some printfs: You can see two thing. Null nodes,
"a,b" join "pss.(middle,fat).last"
"a ," : "pss ."
"a ," : " ("
"a ," : "middle ,"
"a ," : "fat ,"
"a ," : " )"
"a ," : " ."
"a ," : "last ."
"a ," : " @"
"b ," : "pss ."
"b ," : " ("
"b ," : "middle ,"
"b ," : "fat ,"
"b ," : " )"
"b ," : " ."
"b ," : "last ."
"b ," : " @"
" @" : "pss ."
" @" : " ("
" @" : "middle ,"
" @" : "fat ("
" @" : " )"
" @" : " ."
" @" : "last ."
" @" : " @"
" @" : " @"
High speed The join works really great with the new AI processors. Generally one has very large comma sequences needing searching. Large scale neural nets easy to control an update. Our Huffman generator trees are directed graphs, bot could easily learn the markets if bid and ask structured queues were visible visa thr join machine. Add the data structure for nested block, emphasize high speed scanning down and across the graph with just a pointer adjustment. Likely the wave of the future.
No need for recursive context sw2itch, the pushed state is very simple. I don;t do it. I pointed this out when talking about a python iterator over nested block, just need to save the pointer, and return pointer.
One starting point weill br to convert the Berkeley DB into a graph, write the interface. The with another interface streaming to the off board array processor, I can join them. The join machine presents each of them with the simple call back list. One has freedom to overlaying graph searches, manage their own output, a streaming system, bots love this stuff.
Go way to the bottom of the post in the header file. Most of it is explained clearly.
Anyway, that is what we do here at Redneck Inc, that and taxes. The atcutal executable lines of code in join is about 15. So Redneck wants everyone to know that sequence, and build joins in a variety of hardware, software combinations. Attach them to the python interpreter, along with the automatic S&L machine. Build applications to price the links, have everything run in easily verifiable bot code, finite directed graphs. Basically lazy JSON becomes a simple byte code, and many language forms can generate these search and data graphs. We can dump Google, make it all autonomous roaming bots, guaranteed to run to completion without interference. The entire internet converted into a giant neural network, micro pricing all movement; the singularity 1.5, I bump it a version.
My next step is to use it embedded in python and make a windowing system that looks like a graph output. We can see what the bots are doing.
Bot security
The entire join fits into the instruction cache, easily protected with spectre compatible hardware. Or do tis in micro code, or do this in hardware. Contracts become finite graphs, and the secure attachment execute contracr terms via secure joins. All graphs verifiable prior.
Bot trading
Release a trading graph, it travels the auto markets, and run trading bot attachments. It can grab all the 'out of band'market statistic, bring them home, paying their fee.
Sandbox is entirely 'No Humans Allowed'
No comments:
Post a Comment