Friday, November 4, 2016

Traders paying for an intelligent clock

The pit boss is simply organizing the incoming bid/ask so they clock through the graph with intelligent, step quants chosen to minimize the cost to traders. The traders have the pit boss code, they like wrote it as a shared, 30 line python project. They shook hands, signed a paper, informed the court system, and why they did they use. Traders know its characteristics, and they have put their pit boss on the simulator, it still is, being hit with zillions of semi-random trade sequences.

Traders do not have a two color with the pit boss, the pit boss. Pit boss disappears from the scene once the traders agree on its resolution methods.

Nothing much has been invented except, for a small class of python services, we have expanded he concept of a bounded service to a smooth bounded service, one in which the precision of the service goes as the number of clock cycles, mostly. And that is mainly list methods on fixed size entities, already done. We might like a smooth sort on the tree, but we can make one.

But python security is big, that is mostly 'out of band' relative to the pit, traders will make sure.. Take a sory, for example. For any particular boss, traders know what needs sorting on input, they agree, sign the paper. So, taker a memory view of the pits, the array of singletons just dumped on the bid/ask queue, the pits one step down from the top.. Traders agree on a memory view sort function on the pits. Now, any bot can do that sort, asynchronously on demand. They pay the sort price, but get first look at the results. There is no sort methods that can re-scatter the data.

The pit boss will spend cycles on that sort, as per contract, and will execute the sort asynchronously, based on tree imbalance. We get fair, smooth, in place and tree consistency; and a great sort. Traders will love it! Hell, they wrote it, all six lines of it. They likely hand coded it to the bit level. And these traders are going be very efficient stock traders, in high demand.

Call cost? Bits do not do calls on the graph, generally. We have seen thy the iterator accumulates the array index on descent. So recursive calls are replaced with pop and push of the accumulating index. So we have the tools, the code, here and there.

Dictionaries. I am moving away from those for variable call arguments and moving to a fixed length tuple with default values.

I am trying the boldface those three or four internals, and defined functions, of python that must be smooth. Consider sort and pick, I just invented it. sort and pick runs through the pits, from the current sort pointer, and executes a pick function on the singletons as they are bubble sorted in the pits. The bot drops through when it found it goodie, but leaves the pits sorted, up to that point.

All the traders agree, price that sort, even give it negative price, that sort and pick can be operated, underneath, as a widowed Huffman encoder. The group of traders a closed set (bad idea), but they pay each other to keep the tree well sorted. This is a PayForSevrice pit boss. Effectively, the traders hire the pit boss on demand.

Security. The stronger, more verifiable, more out of band; the more traders jump in, they trust the system. The more semi-random sequences, the more structure in bid/ask to discover, the more efficient the market, the happier the trader

Here is the call, mad by some bot.

for bids in the_pit(sort_select,my_arg_tuple)

Now the selector function takes the tuple of args and looks at each node in the descent. It picks one or looks until the end of the pit. The implication is, all the traders know how sort and select work, they are trading at this site because they wrote, verified, installed, and signed inknpaper on the issue of sort_select.

A technical note on arg_tuple

This is a tuple of arguments, thus by position, not a dictionary. But, that tuple should be set up in the __init__ for the iterator the_pit. That set up is critical, it bounds and insures smoothness over whatever parameter set is allowed, by agreement. So, beerificayion is mainly concerned about the selector function, and looks closely at the argument set up in inity.