Rule110 cellular automata is not the simplest computer

Bitcoin has evolved strong gametheory strategy encoded in its rules in the blockchain and some hardcoded in the software when people took advantage of earlier rules that didnt work so well and the blockchain and its many branches were often argued over which branches should be accepted and under what new algorithms. It is in general supposed to become a decentralized cloud computing free market by encoding instructions for what to calculate and what data to use (like variations on algorithms for neuralnets or matrix multiply or maybe ordinary languages?)... But I've not heard of this being used, at least only experimentally.

Maidsafe and Ethereum may be good systems to also hook in later, but I propose a simpler definition of computing at a lower level to build up from.

Kind of got off subject here to whats possible but mostly I'm asking about possible uses between these 2 systems, this one being mostly theoretical so far.
To what extent are the treelike data in some of the blocks easily compatible with this in being able to name these Branch and Read ops and, in the style of the bmoney paper, hook cryptocurrency into the ability to define any arbitrary recognizer function (like in npcomplete or even turingcomplete, or more commonly referring to publickeys of people who might be chosen to arbitrate in case of a dispute if such datastructs were agreed on within the system to normally include an arbiter and list of addresses to try next if failing for each piece of the computing or other agreements negotiated... In other words, what bitcoin was inspired by when first built, that paper, could we do some of that by turning the internet into one big computer and being able to reliably write functions that return 0 or 1 depending on if bitcoin money has moved to a certain address, with some given certainty, but only if agreed on conditions are also true, and the social structures that may go along with that as can also be encoded in the tree of possible branches and bits somewhere? Is it time for that level of integration of this big mess we call society? Its more practically a question of speed, like how fast the things can reach eachother, because bitcoin is generally not for realtime computing, and I had hoped microtransactions could guide AI evolutions to pay eachother for computing resources and end when none is left.

---

A theoretical 1 bit computer (instead of 32 or 64 bits at a time in hardware) thats simpler than Rule110, is a convenient way to represent huffman compression trees across a global network seamlessly, is naturally understood by AIs since its 1 bit in 1 bit out and repeat (bits or at least vectors or math are AIs native language), and it merges social networking with variables and computing and urls etc.

Here's the definition, in theory...

Theres only 2 things it does, alternating between these:

interface Branch{
Read branch(boolean bit);
}

interface Read{
boolean bit();
Branch next();
}

void exploreWholePossiblyInfiniteComputingWorld(Branch variablePersonWebsiteEtc){
Read if0 = variablePersonWebsiteEtc.branch(false);
if(if0.bit()) exploreWholePossiblyInfiniteComputingWorld(if0.next());
Read if1 = variablePersonWebsiteEtc.branch(true);
if(if1.bit()) exploreWholePossiblyInfiniteComputingWorld(if1.next());
}

//variablePersonWebsiteEtc came from downloaded the next few parts of it from somewhere or one you might put on your website after every change you make, reusing shared object names like publickeys or urls or hashed files in bittorrent or other hash or a twitter name etc.

//you'll want to pay more attention to which paths end where, instead of exploring for no reason. For example, a path that has ends directly after each branch, and you back up and take the other path, and it has only 1 path and so on, until there are no paths, that represents a bitstring, which could be a sentence or any data or named thing in the world, whatever you use it for. Things are named by list of bits that way. Everything in computers is made of bits.

For hooking this into urls and downloading from them, a kind of Branch would have to be created that remembers the parts of url already added 1 bit at a time and when you branch it gives you an object representing 1 more bit that you said, so after you come to the end of the url or anywhere in the middle to view its tree, the next bits would be the content returned, like html bytes or whatever is there, except if it appears to be a definition of a Branch object then that url is its name and it just continues as if the content of that url didnt happen and you continue branching as if the next website or part of the system extends onto that url. For example, you could mount any website into a path in your website anonymously, and it would look like they just typed a url in your website but somehow got a Branch object that, if used, downloads from someone elses that your website actually gave as page content part way through the url. This would be able to unify and simplify many things.

Great discovery, that Rule 110, but not a practical system at least nobody has found a way yet. This branch/read 1 bit computer definition, unlike rule110, can handle constant data and addresses with people whose website or piece of computing it is publish an update and if you happen to find that update, because publish is great but like twitter's use of publish/subscribe it doesnt scale if everyone could be affected recursively by most others.

Computing is a bigger than infinite space, meaning the halting problem is demonstrated in this tree of Branch/Read containing loops and potentially expanding into complexity forever depending on which path you take, but it will always continue to give you 1 bit when you give it 1 bit and continue from there. The bits just might be useless after some point or you missed where you should have turned back and combined them in a different way earlier.

The internet would waste much less bandwidth if we had multiple shared huffman abbreviation trees which we can all be a part of, as Branch on bits is what Huffman does, read some bitstring until it ends then tell us what the zip file actually had there before compressed. We could do that while computing, all the time automatically, so instead of resending an entire program to different people, its internal workings could be partially cached and have their own addresses, each a publickey or defined branching from one which had that data in their website content when we looked for their address.

A useful thing many vars/people/websites might do is everyone include something called "mylist" which can be anyone or anything in the system, and you reorder it by your preference of whats most important at the time and you can put stuff inside other stuff like folders (allowing things to be in multiple places at once for almost no extra cost), so your social network and computing and exploring the web could all be organized by drag and drop of these unified objects, if everyone was a circle with their picture and a list on screen and you could grab anyone and open their circle and so on, including the items in your own list becoming their own circles and people could draganddrop those into their lists, or for the more technically minded, use it at the bit level where mylist would come after a certain prefix in the huffman tree. Unlike today's cloud computing, this could have pointers between different programs across different websites. Makes no difference. Computing is computing if you dont first assume an outdated address and website format and just stick with the basics of computing it can be built up from and hooked in.

Computing shouldnt be so complex you cant see the simplest part.