Introduction to a decentralized, autonomous institution: Part One

Corporations, as US presidential candidate Mitt Romney reminds us, are just people. Whether or not you agree with the conclusions his supporters draw from this claim, the statement certainly holds a great deal of truth. What is a company, after all, but a specific group of people working together under a specific set of rules? When a company owns real estate, what it really means is that there is a legal contract that stipulates that the property can only be used for certain purposes under the control of the people who currently sit on its board of directors – a classification itself subject to amendment by a certain group of shareholders. If a company does something, it is because its board of directors has agreed that it should be done. If a company hires employees, it means that the employees agree to provide services to the company’s customers under a certain set of rules, particularly involving payment. When a company’s liability is limited, it means that certain people are given additional privileges to operate with less fear of prosecution by the government – ​​a group of people who have greater rights than ordinary people acting alone, but in the end they are human beings. that. However, it is more than just people and contracts along the way.

However, there is a very interesting question: do we really need people? On the one hand, the answer is yes: although some future post-singularity machines will be able to survive on their own, for the foreseeable future some type of human action will simply be necessary to interact with the physical world. But on the other hand, over the past two hundred years, the answer has increasingly been no. The Industrial Revolution allowed us, for the first time, to begin replacing human labor with machines on a large scale, and now we have advanced digital factories and robotic arms that produce complex goods like cars on their own. But that’s just automation of the bottom; Removing the need for ordinary manual workers, replacing them with fewer professionals to maintain the robots, while the company’s management remains unchanged. The question is: Can we approach the problem from the other direction: Even if we still need humans to perform some specialized tasks, can we remove management from the equation instead?

Most companies have some sort of mission statement; Often it is about making money for shareholders; Other times, it includes some ethical duties related to the particular product they’re creating, and other goals like sometimes helping communities get into the mix, at least in theory. Currently, this mission statement only exists insofar as it is interpreted by the Board of Directors and, ultimately, shareholders. But what if, using the power of modern information technology, we could encode a mission statement into code; That is, creating an inviolable contract that generates revenue, pays people to perform certain jobs, and finds hardware for itself to operate on, all without any need for top-down human guidance?

Also let’s talk about Daniel Larmier from Bitcoin pointed out In his own exploration of this concept, in a sense, Bitcoin itself can be seen as a very early prototype of something exactly like this. Bitcoin has 21 million shares, and these shares are owned by what can be considered Bitcoin shareholders. It has employees, and it has a protocol to pay them: 25 bitcoins to one random member of the workforce roughly every ten minutes. It even has its own marketing department, which is largely made up of the contributors themselves. However, it is also very limited. She knows almost nothing about the world other than the present, has no way to change any aspect of her job except difficulty, and she actually knows nothing about the world. Do Anything in itself; It simply exists and is left for the world to discover. The question is: Can we do better?

account

The first challenge is obvious: how can a company like this actually make any decisions? It is easy to write code that takes a given input and calculates what action to take, at least under predictable environments. But who will run the code? If the code exists simply as a computer program on a particular device, what’s to stop the owner of that device from shutting down everything, or even modifying its code to make it send all of its money to itself? There is only one effective answer to this problem: distributed computing.

However, the type of distributed computing we are looking at here is not the same as the distributed computing in projects like SETI@home and Folding@home; In these cases, there is still a central server that collects data from distributed nodes and sends requests. Instead, what we need here is the kind of distributed computing we see in Bitcoin: a set of rules that decentralizes and self-validates its computations. In Bitcoin, this is achieved through simple majority voting: if you do not help calculate the blockchain using the majority power of the network, your blocks will be discarded and you will not receive any block reward. The theory is that no attacker would have enough computer power to subvert this mechanism, so the only viable strategy is to basically “go with the flow” and act honestly to help support the network and get the block reward. Can we simply apply this mechanism to decentralized computation? In other words, can we simply ask every computer in the network to rate a program, and then reward only those whose answer matches the majority vote? The answer is unfortunately no. Bitcoin is a special case because Bitcoin is simple: it’s just a currency, carrying no property or data of its own. On the other hand, a virtual company will likely need to store the private key of its Bitcoin wallet – a piece of data that should be fully accessible. no one, and not for everyone the way Bitcoin transactions are done. But, of course, the private key must remain usable. Therefore, what we need is some system to sign transactions, and even generate Bitcoin addresses, which can be calculated in a decentralized manner. Fortunately, Bitcoin allows us to do just that.

The first solution that might immediately come to mind is multi-signature addresses; Given a pool of thousands of computers that can be relied upon to continue supporting businesses, have each of them generate a private key and create a multi-signature address of 501 out of 1000 between them. To spend funds, simply create a transaction with signatures from any 501 nodes and broadcast it to the blockchain. The problem here is clear: the deal will be too big. Each signature is about seventy bytes, so 501 of them would make a 35KB transaction – which is very difficult to accept in the network as bitcoind by default Rejects transactions with any script larger than 10,000 bytes. Second, the solution is specific to Bitcoin; If a company wants to store private data for non-financial purposes, multi-signature scripts are useless. Multi-signature addresses work because there is a Bitcoin network that evaluates them, and places transactions into the blockchain depending on whether the evaluation is successful or not. In the case of private data, a similar solution would essentially require some decentralized authority to store the data and grant it only if the request had 501 out of 1,000 signatures as needed – which brings us back to where we started.

But there is still hope for another solution; The generic name given by cryptographers is “secure multiparty computation.” In multi-party secure computation, the inputs to the program (or, more precisely, the inputs to a simulated “circuit”, as multi-party secure computation cannot handle “if” statements and conditional loops) are partitioned using an algorithm calledShamir’s secret sharingPart of the information is given to each participant. Shamir’s secret share can be used to split any data into N parts such that any K of them, but no K-1 of them, are sufficient to recover the original data – you can choose what K and N are when running the algorithm. 2 out of 3, 5 out of 10, and 501 out of 1000 are all possible. The circuit can then be evaluated on pieces of data in a decentralized manner, so that at the end of the calculation each person has part of the result of the calculation, but at no point during the calculation does any individual get the slightest glimpse of what is going on. Finally, the pieces are put together to reveal the result. The running time of the algorithm is O(n3), which means that the number of computational steps taken to evaluate a calculation is approximately proportional to the cube of the number of participants; At 10 nodes, 1,000 computational steps, and at 1,000 nodes, 1 billion steps. A simple billion-step loop in C++ takes about twenty seconds on my laptop, and servers can do this in a fraction of a second, so 1000 nodes is currently roughly the limit for computational practicality.

As it turns out, the secure multiparty account can be used to generate Bitcoin addresses and sign transactions. To generate the address, the protocol is simple:

1. Everyone generates a random number as a private key.
2. Everyone calculates the public key corresponding to the private key.
3. Everyone reveals their public key, and uses Shamir’s secret sharing algorithm to calculate a public key that can be reconstructed from any 501 of the thousands of public keys that have been revealed.
4. An address is generated from this public key.

Because public keys They can be added and subtracted This algorithm works exactly as you would expect. If everyone collects a private key 501 out of 1000 in the same way, that private key will be able to spend the money sent to the address generated by applying the 501 out of 1000 algorithm to the corresponding public keys. This works because Shamir’s secret sharing is really just an algebraic formula – that is, it only uses addition, subtraction, multiplication, and division, and one can compute this formula “on” public keys just as easily as one can with addresses; As a result, it does not matter whether the private key was converted to a public key before or after the algebra. Signature transactions can be done in a similar way, although the process is somewhat more complicated.

The beauty of a secure multiparty account is that it extends beyond just Bitcoin; It can easily be used to power the AI ​​algorithm that the company relies on to operate it. So-called “machine learning,” the common name for a set of algorithms that detect patterns in real-world data and allow computers to model them without human intervention, and are used extensively in fields such as spam filters and self-driving cars, is also “just algebra.” It can be implemented in secure multi-party accounts as well. Really, any computation can do this, if that computation is broken down into a circuit over the individual bits of the input. Naturally there is some limit to the possible complexity; Converting complex algorithms into circuits often introduces additional complexity, and as noted above, sharing Shamir’s confidentiality can become expensive in itself. Therefore, it should only be used to implement the “core” of the algorithm; More complex high-level thinking tasks are best solved by outside contractors.

Excited about this topic? Look forward to Parts 2, 3, and 4: how decentralized companies can interact with the outside world, how some simple secure multiparty computation circuits work at a mathematical level, and two examples of how these decentralized companies can make a difference in the real world.

See also:

http://letstalkbitcoin.com/is-bitcoin-overpaying-for-false-security/