Topic: MerkleWeb - statistical Godel-like secure-but-not-perfect global Turing Machine - page 3. (Read 12245 times)

I described the voting system referred to by markm some years ago, you can read it in this doc. It explains how to implement it:

https://docs.google.com/document/d/1jidmNJHWAtsPLCUD7EPPm8jOEV93kSXbZOMycqCWOyA/edit?authkey=CN7BnLUG

You could theoretically broadcast the votes and incorporate them into a block chain, but in practice I think nobody would accept a voting system that could be overridden or DoSd by a sufficiently powerful attacker. More likely, you would submit votes to several independent voting authorities who would then publish the votes they received publically. You could check your own vote appeared correctly. Problems would soon become apparent.

Instead of debating the details of which kinds of voting systems and ways to pair public-keys with people, and other parts of how a democracy could be built, and the balance between encrypted privacy (encryption is made of NANDs like all other software) and optimizations based on shared data structures, lets focus on how to give everyone the ability to experiment with many combinations of those things, and new kinds of interactions between people we've never thought of, and see which works best. Instead of focusing on who has how much power and who gets to control who else, lets work together globally to create a consistent model of how we all think the world works, how global power flows, why laws get created as a reaction to what other things, the game-theory and global strategy of it all, how science and psychology and all other paradigms fit together, into one model of how the world works that a majority of 7 billion people agree is close enough to how the world works. Then we decide what possible futures we the people prefer, and use the simulation/model of how the world works to find probable paths from where we are now to our preferred futures. Lets proceed scientifically instead of fighting through different ways to do politics. Life is a positive sum game. You don't have to lose for me to win. Lets find ways to increase the number of positive sum games in how the world works, like I did when I chose not to patent and sell this new kind of system design. Its public domain, an open specification for the world to work together.

As we know from stock markets, accuracy of prediction is a kind of money. If we can globally majority-agree on a simulation/model of how the world works, which repeatedly makes very accurate predictions of what happens next globally, we create a stock market of predictions of how the world will change. Money runs the world, in corporations and governments. If many buy stock in the prediction that a certain country will try to shut down their Internet, for example, that's something that wasn't allowed in the existing stock markets. They are limited to the fluctuating money values of businesses. I'm not saying it has to be a stock market of money. We can trade the value of predictions directly for the value of other predictions, or for Bitcoins or dollars or whatever other forms of value. With a global unbiased Universal Turing Machine for us all to experiment and communicate and design new ways of interaction and ways of organizing groups of people, the data-structures called "business" and "government" are going to have to justify their continued usefulness before we emulate in software all the useful things they do and they become consumers of our more accurate predictions of the world, unable to contribute anything within the constraints of their obsolete system, their effective power draining away like Bitcoin moved 100 million of value from dollars into bitcoins without putting in any money to get it. That is what a unified unbiased global system can do, and we haven't even got into what a grid of people wearing Emotiv Epoc mind reading game controllers, or other brain related technology, could do together.

The requirement for the cpu registers, address bus, memory, and other emulated hardware components, all combined into one kind of NAND based bit space instead of many separate components as computers are built today... the requirement for that to be a quine made of NANDs that generate their own definition in a loop, is very important. As a quine, it can rebuild itself if parts of it get broken or computers disagree on what kind of logic or state of the bits are in the system at any one 320 address (256 space and 64 time). When such disagreements occur ("11" bits in virtual 321 address space, at the leafs of some of the Merkle Trees in the constants section), the quines evolve and branch and merge like DNA duplicating itself, but as combinations of NANDs instead of A, C, T, and G molecules.

MerkleWeb, as I defined it, would be a http://en.wikipedia.org/wiki/Friendly_artificial_intelligence because of that quine and DNA-like evolution of the NAND logic which evolves toward global consistency of the whole system. It evolves toward exponential certainty of acting exactly as a Turing Machine, a normal computer. Its not even an AI in the normal definition of the word. In the SVN-like versioning and branching of the states (including computing states) of the whole Internet, disagreements between the computers of what the 1 global computer is doing must be solved somehow. I'm simply calling that process the AI, the blind no-intelligence backtracking to previous states of the system and emulating whats missing so the whole system can proceed. Bio evolution is blind and lacking intelligence too, but it evolved Human brains. It is a http://en.wikipedia.org/wiki/Friendly_artificial_intelligence because it has no goals of its own, no desire toward any specific outcome, except to be a Turing Machine and do whatever calculations we give it, and because it has exponential selection-pressure toward a globally consistent state of the system.


MerkleWeb has alot of potential, its power coming from simplicity of only supporting NAND and forming its cpu, address bus, memory, and/or a decentralized unification of those ideas from a quine of self-referencing NANDs. For example, since no system in the MerkleWeb network has an address (no HTTP, no IP address, nothing), it is theoretically possible as nanotechnology advances to run a "wireless mesh network" of computronium dust (as some science fiction has called nanotech wireless mesh networks), each particle of dust broadcasting a small part of the calculations to the near particles of dust, all solar powered to power their millimeter range wireless transmissions. I don't know how to build such hardware, but MerkleWeb would work on a planet tiled with such dust particles as well as bigger network routers and grids of GPUs. The algorithm, as I've logically bounded it to prove certain behaviors as it scales (while lacking some details within those bounds like what kind of address bus, if any)... the algorithm is nonlocal, exponentially error tolerant, and scale-free.

If you allow proxy voting as in "just count me down as voting the same way that guy there votes" then you could issue one babyvote per birth certificate issued and one per verified baby-who-turned-18 or whatnot, and simply not care who they (or their parents in the xcase of babyvotes maybe) end up passing along their proxy to. Hmm might lead to oligarchy though if you can't figure out which votecoin corresponds to which actual living person in order to cancel theirs when they die. SO might want to jsut put a time limit on it. Maybe issue decadeofvoting tokens that expire in a decade.

The main point being, blind them so you don't know nor care whether the entity it was issued to chose a republic style (voting for representatives intead of directly on issues, implemented in this simply by giving your vote to your "representative" to cast on your behalf as they please) or a democratic style (hold it yourself, cast it yourself, instead of giving it to a rep or trading it for a bowl of porridge or whatever).

Open Transactions planned voting system could maybe handle that kind of approach.

-MarkM-

I've been thinking about this lately, but I don't know how to do it without associating people to keypairs and making public everyone's vote.

Another service I understand merkleweb could perform is cloud and "trusted" computing. I mean I can run my program in google's app engine but I cannot tell for sure if google is really running my algorithm or a modification of it. Google could also do whatever he wants with the data of my application. After thinking a little about it, I came to the conclusion that what I wanted was impossible but maybe this merkleweb can do it.
I'm still skeptical but I haven't really understood how it works yet. I have to re-read the thread more carefully.

It would be the first unbiased secure global computer. There are many cloud and grid systems, but they are designed for specific hardware and/or specific tasks, and they're highly biased toward the advantage of whoever owns them. MerkleWeb would be everyone's shared computing platform. Since we all own it, the only cost of using the network (except for business systems that we may choose to access) is owning a computer or other device to hook into it. There would be no Internet Service Providers blocking our path to the Internet and charging us for access on the condition we agree to their legal terms. There would be no legal terms. Since we would all own it, there's nobody to ask for permission. That's if we do it as a wireless mesh network. We would start in an emulated version running on the existing Internet and later the existing Internet would be emulated on our shared global wireless grid.

There is 1 "killer app" that can only run on MerkleWeb: a global voting system through digital-signatures, everyone having their own private-key(s) like in Bitcoin, certified identities through certificate-authorities or "network of trust" decentralized algorithms, or anonymous like Bitcoin doesn't associate names with public-keys. Since the global computer would have military-strength Bitcoin-like security on every bit and NAND calculation, and this is all visible for peer-review, people could trust that their votes are counted correctly by a simple code to loop over them and sum for each thing voted on. Anyone could start a vote, which of course has military-strength security and hooks into shared public-key systems that we can build on top of the Turing Machine, not just to vote in people, but a vote on who we want to impeach or what we want to change. We could vote for or against legalizing marijuana, for example, and when we prove in a country or globally (or wherever the vote is) that a majority of people is for or against it, our "elected" leaders will have a very hard time justifying going against the will of the people, and if they continue to ignore majority agreement, they risk things like a much bigger Wall Street Protests that spreads globally in a much bigger way. They control us by telling us what we're allowed to vote on. We the people choose what to vote on. Democracy tells government what to do. Is freedom and democracy enough reason for people to help create and use MerkleWeb?

Eventually MerkleWeb would run video games and other software incredibly fast. We would set the "global heartbeat" interval to the clock rate of graphics cards, synchronize every billion cycles or whatever rate, backtrack and recalculate (only affected parts of the system) more often as a result, run grids of programmable GPUs 24 hours per day, and whoever is using MerkleWeb at the time gets some of that bandwidth.

We can do that because we don't have to verify every bit to prove to exponential certainty what those bits are. We just make sure enough bits at the end of a long sequence of GPU calculations match what everyone else expects, and if even 1 bit is unexplained in the whole MerkleWeb, it automatically backtracks only affected parts of the system (from the SVN-like versioning of the whole network based on continuous diffs, which is the normal way it works not the exception) and as much of the network as needed quickly recalculates, going down to the emulated NAND level if necessary to replace a calculation from a hardware that broke in the middle of a calculation.

Whats the personal incentive? Use huge grids of GPUs, like Bitcoin has for mining, as general purpose CPUs, to run all programs on MerkleWeb.


That's just a way to synchronize the bit state of the system, of all 2^320 virtual bits. I didn't define which combinations of bits map to which NAND calculations because there are many ways to do it that work. Motherboards have address busses, access to specific parts of a memory stick, DMA memory mapping, cache levels, and many other systems. Its all NAND logic or calculations that can be derived from NAND. We first need to create a prototype address bus and CPU registers, but in more decentralized way that combines the ideas of CPU and memory and address bus into one kind of thing. After that is defined, then we get to use 256+64 bit numbers as addresses in the system of things to NAND, and using that ability we write the definition of the "CPU and memory and address bus into one kind of thing" that we used to build the "CPU and memory and address bus into one kind of thing", a quine. It has to be a Universal Turing Machine, a Turing Machine that comes with a data format of how to specify other Turing Machines for it to emulate, and we tell it how GPUs and other hardware works, SHA256 hash the NAND level description of the GPUs into a 256+64 bit address, and use that address as the name of that GPU logic, to be called from anywhere in the network like any other function in the system. We should start with a single function (that we first have to derive in a quine way, as I already explained about the whole system being a quine) that does a single NAND calculation. There are still lots of details to work out, but I've logically bounded the task enough to know it will run at practical speeds if we build the right hardware.


If we build it as a grid of GPUs and wireless mesh network, it would do everything the existing Internet does but better, in a unified address space. There would be no HTTP. There would be a 320 bit address you read and write like its in the same computer. VMWare Fusion, in unity mode, lets you run Windows and Macintosh programs side by side and copy/paste between them. Think of MerkleWeb as "unity mode" for the whole Internet.

I've read your original post a couple of times now, with great care.  It does not make sense to me.  I would like to understand it, though.  Here are a couple of questions:

1) What will the incentive to run this computation be, at a personal level?

2) How does the bloom filter, the Goedel framework, and the SHA256 hashing relate to arbitrary computation?

Your exposition would be a lot clearer if you presented a simple concrete example of a MerkleWeb in operation, showing step by step how it would perform some useful computation.  At this stage I simply have no idea how it would work or what merit it would have.

Its not a Java system. I also gave VMWare and Windows as examples, but its not those systems either. I'm simply planning to implement a small prototype in Java since Java has a consistent specification document that its implementations obey, unlike C++ for example, and because most of my open source software http://sourceforge.net/users/benrayfield is converging toward a shared Java network infrastructure.

The best system for an implementation of MerkleWeb would be in a peer to peer network of a new kind of Turing Complete wireless network router, like the "mesh networks" that people are building to overcome censoring of their Internet and their rights to communicate (in words or in bits or any form of communication they choose).

A more advanced form of this network router would include a small machine that prints NAND gates onto silicon and automatically integrates them as permanent parts of its own circuits and maps them into the 320 bit global address space as a paravirtualization hook defined by the SHA256 hash of the NAND logic it implements. As that new 320 address is broadcast to everyone who it tends to be useful for, they will have the ability to take it apart, put it back together in more useful ways, and print it as it is or print their modified versions into their own hardware as NAND gates.

Its simple for MerkleWeb to calculate which NAND gates to print since its based on NAND logic from the start. Its a simple matter of counting which combinations of NAND occur in the public part of the Internet most often.

MerkleWeb is much more like Scheme than Java. The MerkleTrees are Continuations of the whole MerkleWeb or large parts of it, a more advanced kind of Continuation since its used statistically and in combination with many other Continuations flowing through MerkleWeb, a self-referencing harmony of mathematical precision.

EDIT: I've updated the http://sourceforge.net/projects/merkleweb description to:
Absolute minimalist open spec of whats needed to obsolete and rebuild entire Earth infrastructure, as global peer to peer 320 bit (256 space, 64 time) address quine Turing Machine, military-strength Bitcoin-like security on every bit and NAND calculation, from NAND gates, software NAND logic, recursive paravirtual hooks (run Windows, Mac, and Linux on global cloud through VMWare or other emulators) at paravirtual optimized realtime speed. Runs slowly on existing Internet. Best system would be wireless mesh network of new kind of Turing Complete routers. No system has an address. They're redundant computing power and storage for the 1 global Turing Machine. End to end branch prediction, global rollbacks, snapshots and SVN-like branching whole network, recalculation if 1 bit is found through NAND-level quine Godel-like error checking codes in Merkle Trees. Supports evolvable hardware as paravirtual hook into global address space of SHA256 hash of NAND definition of new hardware. Freedom.

"I wish I had a shilling for every senseless killing. I'd buy a government. America's for sale, and you can get a good deal on it, and make a healthy profit. Or maybe, tear it apart. Start with assumption, that a million people are smart, smarter than one." --NOFX, The Decline

With a global secure peer to peer Turing Machine and digital-signatures, we can trivially implement a global democracy. Counting votes becomes as simple as writing the code to loop over them and sum. Every bit and NAND calculation in MerkleWeb has military-strength security. The only errors, proven to exponential certainty using the Bitcoin security model at the bit and NAND level, are the errors we command the Turing Machine to create. We can command MerkleWeb to print "2=3", but that is our error, not the Turing Machine's error. In a world where "national security" is higher than Earth Security, we need an unbiased shared computing platform everyone can trust.

Oh wow  

That is like the most awesome bitcoin sidekick project I've seen. Except that it is proposed to be written in java (which I don't like  )

When I build a prototype of this public domain open specification, it will be at http://sourceforge.net/projects/merkleweb

MerkleWeb is based on a variation of the Bitcoin security model.


MerkleWeb - a statistical Godel-like secure-but-not-perfect proof system for a global realtime peer to peer Turing Machine

Start with a 256 bit address space where each address points at a specific one of 2^256 virtual bits, not a byte or int like many hardwares take shortcuts in the consistency of their designs.

Add a 64 bit address space for time, so any past, present, or future state.

Use that as a combined 320 bit address space, where each address points at a specific one of 2^320 virtual bits.

Add 1 bit to the 320 bit addresses, so a 321 bit address points at a Godel-like statement which means "This specific one of 2^320 virtual bits is a 0 bit" or at "This specific one of 2^320 virtual bits is a 1 bit".

In 321 address space, there are 2 bits mapping to each bit in 320 address space.

If those bits, aligned at even bit indexes, are 10, it means "This specific one of 2^320 virtual bits is a 0 bit".

If 01, it means "This specific one of 2^320 virtual bits is a 1 bit".

If 00, it means "This Godel-like statement does not know if the specific one of 2^320 virtual bits is a 0 bit or a 1 bit".

If 11, that is a contradiction and must be backtracked until a state of the system is found that, as proven to exponential certainty but not Godel-like certainty, is a consistent state of the system.

Put constants near the end of time in 64 bit address space so they do not interfere with the Turing Machine running in the lower half for up to 2^63 cycles.

Name constants by their SHA256 secure-hash, so it is exponentially certain their name will never overlap any other constant in the whole system. The 320 address of any constant bit string is the 256 address from its SHA256 hash and the 64 time address of 2^64 minus its bit length, which can be calculated in twos-complement integer math as -bigLength, so if you're using Java's long number type for example, the constant bit string starts at a 320 address, and you increment the long until it rolls over to 0, each time observing 1 bit in the constant bit string that is named by that 320 bit address.

A Merkle Tree is a tree of secure-hash names of other Merkle Tree nodes, ending at any leaf data. Bitcoin uses Merkle Trees to keep its peer to peer network secure as the whole network globally agrees on who has how much money and who has sent and received how much money from who else. MerkleWeb (this software I'm planning) will use MerkleTrees similar to how Bitcoin uses them, but to refer to states of a peer to peer globally decentralized Turing Machine instead of money.

Each MerkleTree recursively refers to specific values for each of 2^321 bits, which is approximately 1 googolbit.

As parts of the system flow through the Internet and learn about other parts of the system, new MerkleTrees are created that have more "10" and "01" (adjacent bits, aligned at even index, in 321 address space) than "00" (which means don't know if its 0 or 1 in 320 address space). Each of those "parts of the system" is a MerkleTree that combines other MerkleTrees in usually different combinations than other MerkleTrees combine them.

Every 2 MerkleTrees that have equal childs are the same MerkleTree and have the same 320 address, since its made of the SHA256 hash of the bits of that MerkleTree (shallow view, only including the 320 address of each child in the hash) and 2^64 minus its bit length which is 320*childs. Therefore if 2 computers on 2 sides of Earth happen to calculate the same MerkleTree as a combination of the same childs and continue calculations based on it, when that information travels across Earth and they learn of eachother's calculations, it fits together since they both calculated the same 320 bit addresses.

In this MerkleWeb system, each MerkleTree, which can be as small as 640 bits, refers to a possibility of the entire state of MerkleWeb and the entire history of MerkleWeb, including all other MerkleTrees which represent other possibilities, an acyclic network of possibilities each referring to many other possibilities.

2 MerkleTrees can only be combined if they do not contradict eachother on even 1 bit. Each MerkleTree represents exact values for each of 2^321 virtual bits, approximately 1 googolbit, so that is not easy to do, but here's the rule that makes it practical for realtime speeds: Since we only store MerkleTrees that, proven to exponential certainty, have no contradictions between their child MerkleTrees recursively, we only need to keep track of which child MerkleTrees are compatible with which other MerkleTrees, and search any MerkleTrees we receive from the peer to peer network recursively comparing their childs to the childs we already have, and use only the parts of them we can prove, to exponential certainty, do not contradict eachother. Each cycle of the network, which I call a "global heartbeat" since these cycles and network hops are time aligned in the whole MerkleWeb, each computer creates a MerkleTree node that recursively refers to the largest set of consistent bits in the 321 bit address space (a possibility, a view of all past and present states of the whole MerkleWeb), and transmits that to peers.

Computers in MerkleWeb ask eachother for specific MerkleTrees, named by a 320 address. When its received, they SHA256 hash it to verify as an absolute proof that it has that 320 address, but there is a exponentially small chance some other computer in the network has a different MerkleTree that has the same SHA256 hash (which has never happened for the SHA256 algorithm), and there is a superexponentially small chance such a contradiction would survive in MerkleWeb as I'll explain as continuous "snapshot-of-the-whole-Internet" below.

The network routing behaviors can be built on top of the Turing Complete layer that MerkleWeb defines as bits. Start with some bit representation of NAND and 320 bit addresses for it to be a CONSTRAINT between, which all other logical operations can be derived from, build it up like a hardware system, build whatever software components you need to make the peer to peer network work, and to exponential accuracy it is accurate to call MerkleWeb and the entire Internet (or whichever parts choose to implement the MerkleWeb open standard) a quine.

NAND is a constraint between 2 bits in the past and 1 bit in the future, not an action. A more flexible definition of NAND would be to let it operate on 3 320 bit addresses, to NAND 2 of their targets and put the resulting bit in the other address. MerkleWeb is flexible and secure enough to work either way or both.

Technically the "acyclic network" is a closed loop allowing self-reference or other forms of cycles and we would get into all kinds of contradictions as Godel proved, but this system will prove to exponential certainty, backed by the security of SHA256 or whatever secure-hash algorithm you think is more secure, exponential certainty that the system is consistent on each computer and in the peer to peer network where local events change things and such information flows here a short time later, we also have a proof to exponential certainty that all these MerkleTrees will quickly fit together into a consistent snapshot of the whole decentralized MerkleWeb, so we can take continuous snapshots of the Internet (whichever parts choose to implement the MerkleWeb open standard) and have a new root MerkleTree snapshot-of-the-whole-Internet thats only a few seconds old, updating it continuously.

We could version and branch the whole Internet, states of its memory and computing states, as a peer to peer based Turing Complete cloud infrastructure, to use the whole Internet as 1 Turing Machine.

The backtracking and recalculating, from the NAND level up (with optional paravirtual optimization if the implementation of MerkleWeb supports it, but that doesn't change behaviors, just do combinations of NANDs faster), is proven to converge at exponential speed in the global peer to peer network because each virtual bit string of exactly 2^321 bits (which a MerkleTree refers to recursively) is a Bloom Filter. A bloom filter is a 1 dimensional array of bits, where all bits start at 0, and the only allowed operation is to change a 0 bit to a 1 bit, but no 1 bit ever becomes a 0 bit.

Bloom filters can be combined if no 2 adjacent bits, the first having even index, are both 1 or become 1. To combine them, OR their bits, verify the "2 adjacent bits" constraint is satisfied, and there is 1 more constraint: The state of the system must be the result of a past state of the system as the NAND logic, implemented in the past bit state of the system, defines.

Proven to exponential certainty, no bloom filter in MerkleWeb will have 2 adjacent bits, an even index and the odd index that goes with it, both being 1, because that would mean the specific bit in 320 bit address space (that those 2 bits in 321 bit address space refer to possibilities of) would simultaneously be 0 and 1. Many computers in the peer to peer network will have MerkleTrees (which each refer to virtual 2^321 bit bloom filters) that disagree with eachother and can not be combined (while some of their childs to some recursive depth can be combined with some of the local childs), but it will all converge as past states of the system and the NAND level definition of how the system must proceed from one state to the next are used for the peer to peer network to agree on how the Turing Machine states proceed in the global MerkleWeb.

MerkleWeb could work for other implementations of Turing Machines, but I chose a 256+64 bit address space because most computers work with address spaces, so existing technology could be mapped into this global address space bit for bit, like VMWare runs Windows with paravirtual optimizations for example, while some parts of the network would have to run at different speeds since network hops are slow and cpu cycles are fast, maybe some combination of darknets and global broadcasts. MerkleWeb is a general way to implement any kind of Turing Machine in a global peer to peer network and converge toward a consistent state continuously.

As I've defined it but not yet built it, MerkleWeb is a secure-but-not-perfect closure on Godel Numbering into 320 bits per Godel Number, a quine, and a peer to peer decentralized realtime practical global Turing Machine, where each Merkle Tree refers to specific values for each of 2^321 virtual bits which are used and combined as bloom filters to prove the system will converge exponentially fast toward consistent states except for the most recent few time cycles.