Polygon Network’s Plonky2- an intriguing 100x scalability solution

Polygon developers have recently announced launch of Plonky2, a scaling solution that uses zero-knowledge proofs to scale the Ethereum blockchain 100x in order to support a billion users.

The intrigue of such game changing improvement is around the Zero-Knowledge cryptography mechanism.

Basic Cryptography Terminology:

zk-SNARK stands for “Zero-Knowledge Succinct Non-Interactive Argument of Knowledge,” and refers to a proof construction where one can prove possession of certain information, e.g. a secret key, without revealing that information, and without any interaction between the prover and verifier.

Zero-knowledge proofs allow one party (the prover) to prove to another (the verifier) that a statement is true, without revealing any information beyond the validity of the statement itself. For example, given the hash of a random number, the prover could convince the verifier that there indeed exists a number with this hash value, without revealing what it is.

Recursion is a method of solving a problem where the solution depends on solutions to smaller instances of the same problem. Such problems can generally be solved by iteration, but this needs to identify and index the smaller instances at programming time. Recursion solves such recursive problems by using functions that call themselves, essentially, breaking down instances to smaller chunks and finally to a predefined solution to the smallest instance.

The theory in a nutshell is that applying recursion on SNARKs, or allowing SNARKS to verify other SNARKS would greatly improve scalability.

Granted these blockchain jargons may sound alienating, let’s go over an example to shed more light. Suppose the objective is to prove a batch of 1,000 transactions are valid. Generating a single proof computation in order to verify these 1K transactions at once would be costly without much explanation needed.

The proposed solution is to take 1,000 machines and generate 1,000 proofs in parallel, one for each transaction. Next, we can take these transaction proofs and recursively aggregate them by generating a layer of recursive proofs, with each one verifying two transaction proofs below. This process will be repeated until we’re left with a single proof that verifies 1,000 transactions.

Such recursive approach is faster, less resource-intensive, and can be more decentralized.

Based on my limited understanding of the Plonky2 paradigm, at first glance it appears a breakthrough upgrad, enough to fuel excitement that translates into large-scale dApp projects.

After further reflection and review of my understanding of Recursion, however, I pose the following question: instead of putting the entire load of computation on a single computer, you break the load up and put each subload across 1000 computers and roll up the results, but, should the cost of requiring 1000 computers not be accounted for?

Perhpas the better conclusion may be that cost of requiring 1000 computers performing subtasks would end up being more expensive initially but would significantly reduce the time cost against complex proofs.

Any recorrections, feedback would be greatly appreciated !