Thanks to Brian Retford, SunYi, Jason Morton, Shumo, Feng Boyuan, Daniel, Aaron Greenblatt, Nick Matthew, Baz, Marcin, and Brent for their valuable insights, feedback, and reviews of this article.
Author: Grace&Hill
Artificial Intelligence has been all the rage for us crypto enthusiasts for a while now. Interestingly, no one wants to see AI get out of control. Blockchain was invented to prevent the dollar from getting out of control, so we might give it a try to prevent AI from getting out of control. In addition, we now have a new technology called zero-knowledge proofs to ensure that things can't go wrong. However, to harness the beast that is AI, we must understand how it works.
A Simple Introduction to Machine Learning
Artificial intelligence has gone through several name changes, from "expert systems" to "neural networks", then "graphical models", and finally evolved into "machine learning". All of these are subsets of "artificial intelligence", and people have given it different names, and our understanding of artificial intelligence is constantly deepening. Let's take a little deeper into machine learning and demystify it.
Note: Today, most machine learning models are neural networks because of their superior performance in many tasks. We primarily refer to machine learning as neural network machine learning.
How does machine learning work?
First, let’s take a quick look at the inner workings of machine learning:
Input Data Preprocessing: Input data needs to be processed into a format that can be used as input to the model. This usually involves preprocessing and feature engineering to extract useful information and transform the data into a suitable form such as input matrices or tensors (high-dimensional matrices). This is an expert system approach. With the advent of deep learning, the processing layers automatically handle preprocessing.
Set initial model parameters: Initial model parameters include multiple layers, activation functions, initial weights, biases, learning rates, etc. Some parameters can be adjusted during training through optimization algorithms to improve the accuracy of the model.
Training Data:
Input data is fed into a neural network, typically starting with one or more feature extraction and relationship modeling layers, such as convolutional layers (CNNs), recurrent layers (RNNs), or self-attention layers. These layers learn to extract relevant features from the input data and model the relationships between these features.
The outputs of these layers are then passed to one or more additional layers that perform different computations and transformations on the input data. These layers typically involve mostly matrix multiplications of learnable weight matrices and the application of non-linear activation functions, but may also include other operations such as convolutions and pooling in convolutional neural networks, or iterations in recurrent neural networks. The outputs of these layers serve as input to the next layer in the model, or as the final predicted output.
Get the output of the model: The output of a neural network calculation is usually a vector or matrix representing the probability of image classification, sentiment analysis score, or other results, depending on the application of the network. There is usually also an error evaluation and parameter update module to automatically update the parameters according to the purpose of the model.
The output of a neural network calculation is usually a vector or matrix representing the probability of image classification, sentiment analysis score, or other results, depending on the application of the network. There is usually also an error evaluation and parameter update module that automatically updates the parameters according to the purpose of the model. If the above explanation seems too obscure, you can refer to the following example of using a CNN model to identify apple pictures.
The image is loaded into the model in the form of a matrix of pixel values. This matrix can be represented as a 3D tensor with dimensions (height, width, channels).
Set the initial parameters of the CNN model.
The input image passes through multiple hidden layers in a CNN, and each layer applies convolutional filters to extract increasingly complex features from the image. The output of each layer passes through a non-linear activation function and then pooling to reduce the dimensionality of the feature map. The last layer is usually a fully connected layer that generates output predictions based on the extracted features.
The final output of the CNN is the class with the highest probability. This is the predicted label for the input image.
A Trust Framework for Machine Learning
We can summarize the above into a machine learning trust framework, which includes four basic layers of machine learning. The entire machine learning process needs these layers to be trustworthy in order to be reliable:
Input: Raw data needs to be preprocessed and sometimes kept confidential.
Integrity: The input data has not been tampered with, has not been contaminated with malicious input, and has been properly pre-processed.
Privacy: Input data will not be disclosed if necessary.
Output: Need to be accurately generated and transmitted
Completeness: The output is generated correctly.
Privacy: Outputs are not disclosed if required.
Model type/algorithm: The model should compute correctly
Completeness: The model executes correctly.
Privacy: The model itself or the computations are not disclosed if necessary.
Different neural network models have different algorithms and layers, suitable for different use cases and inputs.
Convolutional neural networks (CNNs) are often used for tasks involving grid-like data, such as images, where local patterns and features can be captured by applying convolution operations to small input regions.
On the other hand, Recurrent Neural Networks (RNNs) are well suited for sequential data such as time series or natural language, where the hidden states can capture information from previous time steps and model temporal dependencies.
Self-attention layers are very useful for capturing relationships between elements in an input sequence, making them very effective for tasks such as machine translation or summarization where long-range dependencies are crucial.
There are other types of models, including Multi-Layer Perceptron (MLP) and others.
Model parameters: In some cases, parameters should be generated transparently or democratically, but in all cases not susceptible to tampering. Integrity: Parameters are generated, maintained, and managed in the right way. Privacy: Machine learning model parameters are often kept secret by model owners to protect the intellectual property and competitive advantage of the organization that developed the model. This was only very common before transformer models became insanely expensive to train, but it is still a major issue for the industry.
The Trust Problem in Machine Learning
With the explosive growth of machine learning (ML) applications (CAGR of over 20%) and their increasing integration into everyday life, such as the recent popularity of ChatGPT, the trust issues of machine learning are becoming more critical and cannot be ignored. Therefore, it is crucial to identify and address these trust issues to ensure responsible use of AI and prevent its potential misuse. But what are these issues? Let's take a deeper look.
Lack of transparency or provability
Trust issues have long plagued machine learning for two main reasons:
Privacy nature: As mentioned above, model parameters are usually private, and in some cases, model inputs also need to be kept confidential, which naturally brings some trust issues between model owners and model users.
Algorithmic black boxes: Machine learning models are sometimes called “black boxes” because they involve many automated steps in their computation that are difficult to understand or explain. These steps involve complex algorithms and large amounts of data, resulting in uncertain and sometimes random outputs, making the algorithms vulnerable to accusations of bias or even discrimination.
Before going any further, one of the larger assumptions of this article is that the model is “ready to use,” meaning it is well-trained and fit for purpose. Models may not work in all situations, and while models improve at an incredible rate, the normal lifespan of a machine learning model is between 2 and 18 months, depending on the application.
A detailed breakdown of the machine learning trust problem
There are some trust issues in the model training process, and Gensyn is currently working on generating valid proofs to facilitate this process. However, this article focuses on the model inference process. Now let's use the four building blocks of machine learning to discover potential trust issues:
enter:
Data source is tamper-proof
Private input data cannot be stolen by model operators (privacy issue)
Model:
The model itself is as accurate as advertised
The calculation process is completed correctly
parameter:
Model parameters have not been changed or are consistent with the advertised
In the process, model parameters that are valuable to the model owner are not leaked (privacy issue)
Output: Output results that are provably correct (and may improve as all of the above elements improve)
How to apply ZK to the machine learning trust framework
Some of the above trust issues can be solved by going on-chain; uploading inputs and machine learning parameters to the chain and calculating the model on the chain can ensure the correctness of inputs, parameters, and model calculations. But this approach may sacrifice scalability and privacy. Giza is doing this on Starknet, but due to cost issues, it only supports simple machine learning models like regression, not neural networks. ZK technology can solve the above trust issues more effectively. Currently, ZK in ZKML usually refers to zkSNARK. First, let's quickly review some basic concepts of zkSNARK:
A zkSNARK proof is a proof that I know some secret input w such that the result of this computation f is OUT which is true, without telling you what w is. The proof generation process can be summarized in the following steps:
Formulate the statement to be proved: f(x,w)=true
“I correctly classified this image x using my machine learning model f with private parameters w.”
Convert statements into circuits (arithmetization): Different circuit construction methods include R1CS, QAP, Plonkish, etc.
Compared to other use cases, ZKML requires an additional step called quantization. Neural network inference is usually done using floating point arithmetic, which is very expensive to simulate in the main domain of arithmetic circuits. Different quantization methods make a trade-off between accuracy and device requirements.
Some circuit building methods like R1CS are not efficient for neural networks. This part can be tweaked to improve performance.
Generate a proof key and a verification key
Create a witness: f(x,w)=true when w=w*
Create a hash commitment: Witness w* commits to generate a hash value using a cryptographic hash function. This hash value can be made public.
This helps ensure that private inputs or model parameters have not been tampered with or modified during computation. This step is critical because even minor modifications can have significant effects on the model’s behavior and output.
Proof generation: Different proof systems use different proof generation algorithms.
Special zero-knowledge rules need to be designed for machine learning operations, such as matrix multiplication and convolutional layers, in order to implement sub-linear time efficient protocols for these computations.
✓ General-purpose zkSNARK systems like groth16 may not be able to handle neural networks efficiently due to the computational load being too large.
✓ Since 2020, many new ZK proof systems have emerged to optimize ZK proofs for model reasoning processes, including vCNN, ZEN, ZKCNN, and pvCNN. However, most of them are optimized for CNN models. They can only be applied to some major datasets, such as MNIST or CIFAR-10.
✓ In 2022, Daniel Kang Tatsunori Hashimoto, Ion Stoica, and Yi Sun (founder of Axiom) proposed a new proof scheme based on Halo 2, which achieved ZK proof generation for the ImageNet dataset for the first time. Their optimizations are mainly focused on the arithmetic part, with novel lookup parameters for nonlinearity and cross-layer reuse of subcircuits.
✓Modulus Labs is benchmarking different proof systems for on-chain reasoning and found that ZKCNN and plonky2 performed best in terms of proof time; ZKCNN and halo2 performed well in terms of peak prover memory usage; while plonky performed well, it sacrificed memory consumption, and ZKCNN only works for CNN models. It is also developing a new zkSNARK system designed specifically for ZKML, as well as a new virtual machine.
Proof of Verification: The verifier uses the verification key to verify without the knowledge of the witness.
Therefore, we can show that applying zero-knowledge techniques to machine learning models can solve many trust issues. Similar techniques using interactive verification can achieve similar results, but will require more resources on the part of the verifier and may face more privacy issues. It is worth noting that depending on the specific model, generating proofs for them may take time and resources, so there will be trade-offs when this technology is ultimately applied to real-world use cases.
Current State of Solutions
Next, what are the existing solutions? Note that there are many reasons a model provider might not want to generate a ZKML proof. For those brave enough to try ZKML and a solution makes sense, there are several different solutions they can choose from depending on where their model and inputs are:
If the input data is on-chain, consider using Axiom as a solution:
Axiom is building a zero-knowledge coprocessor for Ethereum to improve user access to blockchain data and provide a more sophisticated digital view of on-chain data. Reliable machine learning computations on on-chain data are possible:
First, Axiom imports on-chain data by storing the Merkle root of Ethereum block hashes in its smart contract AxiomV0, which is trustlessly verified through the ZK-SNARK verification process. Then, the AxiomV0StoragePf contract allows batch verification of arbitrary historical Ethereum storage proofs against the trust root given by the block hashes cached in AxiomV0.
Next, machine learning input data can be extracted from the imported historical data.
Axiom can then apply proven machine learning operations on top; using the optimized Halo2 as a backend to verify the effectiveness of each computational part.
Finally, Axiom attaches a zk proof of each query result, and the Axiom smart contract verifies the zk proof. Any interested party who wants the proof can access it from the smart contract.
If you put the model on-chain, you can consider using RISCZero as a solution:
First, the source code of the model needs to be compiled into a RISC-V binary. When this binary is executed in ZKVM, the output is paired with a computation receipt containing a cryptographic seal. This seal acts as a zero-knowledge argument of computation integrity, associating a cryptographic imageID (identifying the executed RISC-V binary) with the declared code output for quick verification by third parties.
When a model is executed in ZKVM, the computation of state changes is done entirely inside the VM. It does not leak any information about the internal state of the model to the outside.
Once the model has executed, the resulting seal becomes a zero-knowledge proof of the integrity of the computation. RISC ZeroZKVM is a RISC-V virtual machine that can generate zero-knowledge proofs of the code executed against it. Using ZKVM, a cryptographic receipt can be generated that anyone can verify was generated by ZKVM client code. When the receipt is published, no other information about the code execution (e.g., the inputs provided) is revealed.
By running machine learning models in RISC Zero’s ZKVM, it is possible to prove that the exact computations involved in the model were performed correctly. The computation and verification process can be done offline in the user’s preferred environment, or in Bonsai Network, a general-purpose roll-up.
The specific process of generating a ZK proof involves an interactive protocol with a random oracle as a verifier. The seal on the RISC Zero receipt is essentially a record of this interactive protocol.
If you want to import models directly from popular machine learning software such as Tensorflow or Pytorch, you can consider using ezkl as a solution:
First, export the final model as a .onnx file and some sample inputs as .json files.
Then, point ezkl to the .onnx and .json files to generate a ZK-SNARK circuit that can prove the ZKML statement.
Ezkl is a library and command-line tool for doing inference on deep learning models and other computational graphs in zkSNARKs.
Looks simple, right? The goal of Ezkl is to provide an abstraction layer that allows high-level operations to be called and laid out in Halo 2 circuits. Ezkl abstracts a lot of complexity while remaining incredibly flexible. Their quantization model has automatic quantized scaling factors. They support the flexibility to change to other proof systems involved in new solutions. They also support multiple types of virtual machines, including EVM and WASM.
Regarding the proof system, ezkl customizes the halo2 circuit by aggregating proofs (converting hard-to-verify proofs into easy-to-verify proofs through an intermediary) and recursion (which can solve memory issues but is difficult to adapt to halo2). Ezkl also optimizes the whole process through fusion and abstraction (which can reduce overhead through high-level proofs).
It is worth noting that compared to other general zkml projects, Accessor Labs focuses on providing specially designed zkml tools for fully on-chain games, which may involve AI NPCs, automatic updates of gameplay, game interfaces involving natural language, etc.
Where are the use cases?
Solving the trust problem of machine learning through ZK technology means that it can now be applied to more "high-stakes" and "high-determinism" use cases, rather than just keeping up with people's conversations or distinguishing cat pictures from dog pictures. Web3 is already exploring many of these use cases. This is no coincidence, as most Web3 applications run or are intended to run on blockchains, and this is because blockchains have specific properties that allow them to run securely, be difficult to tamper with, and have deterministic computations. A verifiably well-behaved AI should be one that is able to conduct its activities in a trustless and decentralized environment, right?
Use cases for ZK+ML in Web3
Many Web3 applications sacrifice user experience for security and decentralization because that is clearly their priority and infrastructure limitations exist. AI/ML has the potential to enrich the user experience, which is undoubtedly helpful, but it seemed impossible before without compromise. Now, thanks to ZK, we can comfortably see AI/ML combined with Web3 applications without sacrificing too much in terms of security and decentralization.
Essentially, this would be a Web3 application (which may or may not exist at the time of writing) that implements ML/AI in a trustless manner. By trustless, we mean whether it runs on a trustless environment/platform or whether its operations can be proven to be verifiable. Note that not all ML/AI use cases (even in Web3) require or prefer to run in a trustless manner. We will analyze each part of ML functionality used in various Web3 areas. We will then identify the parts that require ZKML, typically the high-value parts that people are willing to pay a premium for proofs. Most of the use cases/applications mentioned below are still in the experimental research phase. Therefore, they are still far away from real-world adoption. We will discuss why later.
Defi
DeFi is one of the few proofs of product-market fit in blockchain protocols and Web3 applications. Creating, storing, and managing wealth and capital in a permissionless manner is unprecedented in human history. We have identified many use cases that require AI/ML models to run permissionlessly to ensure security and decentralization.
Risk Assessment: Modern finance requires AI/ML models for a variety of risk assessments, from preventing fraud and money laundering to issuing unsecured loans. Ensuring that such AI/ML models operate in a verifiable manner means we can prevent them from being manipulated to achieve censorship, thereby hindering the use of the permissionless nature of Defi products.
Asset Management: Automated trading strategies are not new to traditional finance and DeFi. Some people have tried to apply AI/ML-generated trading strategies, but only a few decentralized strategies have been successful. Typical applications in the DeFi field include Rocky Bot from Modulus Labs experiment.
A contract that holds funds on L1 and swaps WEth/USDC on Uniswap.
An L2 contract implements a simple (but flexible) three-layer neural network for predicting future WETH prices. The contract uses historical WETH price information as input.
A simple front-end for visualization and PyTorch code for training regressors and classifiers.
This applies to the "output" part of the ML Trust Framework. Output is generated on L2, transferred to L1, and used for execution. During this process, it cannot be tampered with.
This applies to both the “Input” and “Model” sections. The historical price information input comes from the blockchain. The execution of the model is computed in CairoVM (a ZKVM), and its execution trace generates a ZK proof for verification.
Rocky Bot: Modulus Labs created a trading bot on StarkNet using AI for decision making.
Automated MM and liquidity provision:
Essentially, this is a combination of similar efforts in risk assessment and asset management, just with a different approach in terms of volume, timeline, and asset type. There are many research papers on how to use ML for market making in the stock market. It may only be a matter of time before some of these research results are applicable to Defi products.
For example, LyraFinance is working with Modulus Labs to enhance its AMM with smart features to make it more efficient in capital utilization.
Honorable Mentions:
The Warp.cc team has developed a tutorial project that shows how to deploy a smart contract that runs a trained neural network to predict Bitcoin prices. This fits the “input” and “model” parts of our framework, as the input uses data provided by RedStoneOracles and the model is executed as a Warp smart contract on Arweave.
This is the first iteration that involves ZK, so it belongs on our honorable mention list, but in the future the Warp team is considering implementing a ZK portion.
game
Games have a lot of intersections with machine learning: the grey area in the diagram represents our initial assessment of whether machine learning features in the game part need to be paired with a corresponding ZKML proof. Leela Chess Zero is a very interesting example of applying ZKML to games:
AI Agents
LC0 and the human collective take turns playing the game (as it should in chess).
The shift of LC0 is calculated using a simplified, circuit-fit LC0 model.
Leela Chess Zero (LC0): A fully on-chain AI chess player built by Modulus Labs, playing against a group of human players from the community.
The movement of LC0 has a Halo2 snark proof to ensure there is no intervention of human think tank. Only the simplified LC0 model is there to make decisions.
This fits the “Model” section. The execution of the model has a ZK proof to verify that the computation has not been tampered with.
Data Analysis and Prediction: This has been a common use of AI/ML in the Web2 gaming world. However, we have found very few reasons to implement ZK in this ML process. In order to not have too much value directly involved in this process, it may not be worth the effort. However, if certain analysis and predictions are used to determine rewards for users, then ZK may be implemented to ensure the results are correct.
Honorable Mentions:
AI Arena is an Ethereum-native game where players from all over the world can design, train, and battle NFT characters powered by artificial neural networks. Talented researchers from all over the world compete to create the best machine learning (ML) models to participate in the game battles. AI Arena focuses mainly on feedforward neural networks. In general, they have lower computational overhead than convolutional neural networks (CNNs) or recurrent neural networks (RNNs). Still, currently models are only uploaded to the platform after training is complete, so it is worth mentioning.
GiroGiro.AI is building an AI toolkit that enables the public to create artificial intelligence for personal or commercial use. Users can create various types of AI systems based on an intuitive and automated AI workflow platform. With just a small amount of data and an algorithm of their choice (or a model to improve), users can generate and utilize the AI model of their choice. Although the project is in its very early stages, we are very excited to see what GiroGiro can bring to game finance and metaverse-focused products, so we included it as an honorable mention.
DID and social
In the DID and social space, the intersection of Web3 and ML is currently mainly reflected in the areas of human proof and credential proof; other parts may develop, but it will take longer.
Human Proof
The user's application generates a wallet address locally.
The application uses Semaphore to prove that it has the private key of a previously registered public key. Because this is a zero-knowledge proof, it does not reveal which public key it is.
The proof is again sent to the sequencer, which verifies the proof and initiates the process of depositing the tokens into the provided wallet address. The so-called part is sent along with the proof, ensuring that the user cannot claim the reward twice.
The user generates a Semaphore key pair on their phone and provides the hashed public key to Orb via a QR code.
Orb scans the user's iris and calculates the user's IrisHash locally. It then sends a signed message containing the hashed public key and the IrisHash to the registration order node.
The order node verifies the Orb's signature and then checks if the IrisHash matches what is already in the database. If the uniqueness check passes, the IrisHash and public key are saved.
Worldcoin uses a device called Orb to determine if someone is a real person, not trying to fraudulently verify. It does this by analyzing facial and iris features through various camera sensors and machine learning models. Once this determination is made, Orb takes a group of photos of a person's irises and uses multiple machine learning models and other computer vision techniques to create an iris code, a digital representation of the most important features of an individual's iris pattern. The specific registration steps are as follows:
Worldcoin uses the open source Semaphore zero-knowledge proof system to convert the uniqueness of IrisHash to the uniqueness of user accounts without linking them. This ensures that a newly registered user can successfully claim his/her WorldCoins. The steps are as follows:
WorldCoin uses ZK technology to ensure that the outputs of its ML models do not reveal users’ personal data as there is no correlation between them. In this case, it falls under the “output” part of our trust framework as it ensures that the output is transmitted and used in the expected way, in this case privately.
Revisiting the ML Trust Framework from a Use Case Perspective
As you can see, the potential use cases for ZKML in Web3 are still in their infancy, but they cannot be ignored; in the future, as the use of ZKML continues to expand, there may be a demand for ZKML providers, forming a closed loop in the figure below:
ZKML service providers are primarily focused on the “model” and “parameters” parts of the ML trust framework. Although most of what we see now is more “model” related than “parameters” related. It is important to note that the “input” and “output” parts are more addressed by blockchain-based solutions, either as a source or destination of data. ZK or blockchain alone may not achieve full trustworthiness, but together they might.
How far is it from large-scale application?
Finally, we can look at the current state of ZKML viability and how far we are from large-scale adoption of ZKML.
The Modulus Labs paper provides us with some data and insights into the feasibility of ZKML applications by testing Worldcoin (with strict accuracy and memory requirements) and AI Arena (with cost-effectiveness and time requirements):
If Worldcon used ZKML, the prover memory consumption would exceed the capabilities of any commercial mobile hardware. If the AI Arena competition used ZKML, using ZKCNNs would increase the time and cost by 100 times (0.6 s vs. 0.008 s). So unfortunately, neither of these are suitable for directly applying ZKML techniques to prove time and prover memory usage.
What about proof size and verification time? We can refer to the paper by Daniel Kang, Tatsunori Hashimoto, Ion Stoica, and Yi Sun. As shown below, their DNN inference solution can achieve 79% accuracy on ImageNet (model type: DCNN, 16 layers, 3.4 million parameters), while verification time is only 10 seconds and proof size is 5952 bytes. In addition, zkSNARKs can be reduced to 59% accuracy with verification time of only 0.7 seconds. These results show that zkSNARKing of ImageNet-scale models is feasible in terms of proof size and verification time. The main technical bottlenecks are proof time and memory consumption. Applying ZKML in web3 cases is not technically feasible yet. Does ZKML have the potential to catch up with the development of AI? We can compare several empirical data:
The speed of development of machine learning models: The GPT-1 model released in 2019 has 150 million parameters, while the latest GPT-3 model released in 2020 has 175 billion parameters, an increase of 1,166 times in just two years.
The speed of optimization of zero-knowledge systems: The performance growth of zero-knowledge systems basically follows a "Moore's Law" pace. New zero-knowledge systems appear almost every year, and we expect the rapid growth of prover performance to continue for some time.
Judging from these data, although the development speed of machine learning models is very fast, the optimization speed of zero-knowledge proof systems is also steadily improving. In the future, ZKML may still have the opportunity to gradually catch up with the development of AI, but it needs to continue to innovate and optimize technology to narrow the gap. This means that although there are technical bottlenecks in ZKML in web3 applications at present, with the continuous development of zero-knowledge proof technology, we still have reason to expect ZKML to play a greater role in web3 scenarios in the future. Comparing the improvement rate of cutting-edge ML and ZK, the outlook is not very optimistic. However, with the continuous improvement of convolution performance, ZK hardware, and ZK proof systems tailored to highly structured neural network operations, it is hoped that the development of ZKML can meet the needs of web3, starting with providing some old-fashioned machine learning functions. Although it may be difficult for us to verify whether the information fed back to me by ChatGPT is credible with blockchain + ZK, we may be able to install some smaller and older ML models in ZK circuits.
in conclusion
"Power tends to corrupt, and absolute power corrupts absolutely." With the incredible power of AI and ML, there is currently no foolproof way to bring it under governance. It has been proven time and again that governments either provide the aftereffects of late intervention or outright prohibition upfront. Blockchain + ZK offers one of the few solutions that can tame the beast in a provable and verifiable way.
We look forward to seeing more product innovations in the ZKML space, where ZK and blockchain provide a secure and trusted environment for AI/ML to run. We also expect these product innovations to generate entirely new business models, because in the permissionless cryptocurrency world, we are not limited by the de-SaaS monetization model here. We look forward to supporting more builders to build their exciting ideas in this fascinating overlap of "Wild West anarchy" and "ivory tower elites". We are still in the early stages, but we may already be on our way to saving the world.