LambdaClass's blog about distributed systems, compilers, operating systems, security, machine learning, and cryptography.| LambdaClass Blog
Introduction Ethereum has been quickly evolving to become the financial backend of the World. Research and development in zero-knowledge proofs have allowed Ethereum to scale with rollups, by batching transactions off-chain and then posting an update of the accounts together with a cryptographic proof attesting to the validity of the| LambdaClass Blog
Introduction In this article we review some of the optimizations for the SUMCHECK protocol as discussed in the recent article by Bagad, Dao, Domb and Thaler. The authors tackle the problem of disproportionate cost of field multiplications. In many SNARK applications, the sum-check protocol operates over extension fields, which are| LambdaClass Blog
Introduction In this article we briefly introduce a list of basic properties of multilinear polynomials that are convenient to have in mind when tackling a very interesting piece of work by Bagad, Dao, Domb and Thaler: "Speeding up SUM-CHECK proving". The authors focus on a specific setting for the SUMCHECK| LambdaClass Blog
Introduction The GKR (Goldwasser–Kalai–Rothblum) protocol provides an efficient way to verify computations over arithmetic circuits, avoiding re-execution and reducing the verifier’s work. In our previous post, GKR protocol: a step-by-step example, we explored how the protocol works in detail, focusing on its mathematical structure and walking through| LambdaClass Blog
Introduction Bitcoin was the first blockchain in history, enabling a peer-to-peer electronic cash system for the first time. Introduced in 2008 by Satoshi Nakamoto, it provided an elegant yet simple construction to enable people from across the world to store and exchange value over a permissionless and censorship-resistant network. An| LambdaClass Blog
Introduction At the heart of any Zero-Knowledge Proof (ZKP) system lies the concept of arithmetization, the process of transforming a computational problem into a mathematical problem that can be expressed and verified within a specific algebraic structure, such as polynomials or arithmetic circuits. Within the Binius framework, this arithmetization is| LambdaClass Blog
Warning: This post is more math heavy than other articles. Introduction In this article we continue our study of towers of binary fields, motivated by the proposal of Diamond and Posen for a complete protocol working over fields of characteristic 2, BINIUS. Previously we covered basic arithmetic of field elements| LambdaClass Blog
Introduction The development of general-purpose zkVMs has made writing verifiable applications easier, by allowing developers to write high-level code and then compiling it to RISC-V or another instruction set architecture (ISA) and running it on top of the virtual machine. The virtual machine then generates a succinct proof of execution| LambdaClass Blog
Introduction Ethereum relies on cryptographic data structures to efficiently store and verify its state. One of these structures is the Merkle Patricia Trie (MPT), which powers Ethereum’s state management. After exploring this tool in more depth, it becomes clear that the MPT is a complex structure—far more intricate| LambdaClass Blog
Zero-Knowledge Proofs (ZKPs), which generate evidence for a third party to confirm the accurate execution of a computation, and Fully Homomorphic Encryption (FHE), which enables calculations on encrypted data, will be combined with distributed systems algorithms, that are capable of tolerating significant network failures and similar to those employed by Bitcoin. Together they will be utilized to comply with regulations while creating trustless applications.| LambdaClass Blog
Introduction Few weeks ago, Succinct release their paper Jagged Polynomial Commitments and their verifier using the techniques described there, allowing them to prove Ethereum blocks in around 12 seconds, showing that real-time proving of the chain is possible. While this represents the average case and energy consumption is still high| LambdaClass Blog
At LambdaClass we believe that advancing science requires collaboration across disciplines and sectors. As part of our commitment to supporting scientific research and education, we recently made a donation to the Asociación Argentina de Astronomía (Argentine Astronomical Association), a non-profit organization dedicated to promoting astronomical research and knowledge in Argentina| LambdaClass Blog
We celebrate a year of development on Ethrex and talk about what sets it apart.| LambdaClass Blog
Elliptic curves (EC) have become one of the most useful tools for modern cryptography. They were proposed in the 1980s and became widespread used after 2004. Its main advantage is that it offers smaller key sizes to attain the same level of security of other methods, resulting in smaller storage| LambdaClass Blog
We’re pleased to announce our partnership with Nous Research to help develop Psyche, a decentralized AI training network. The system is designed to allow anyone to contribute to model training using idle compute, making AI development more open, efficient, and verifiable. This initiative addresses a long-standing problem in| LambdaClass Blog
We are very proud to celebrate over 18 months of collaboration between Miden and LambdaClass. The partnership began by helping Miden develop the client, facilitating the execution and proving of transactions for the Miden network. Over time, our collaboration deepened, and we expanded our efforts to support the development of| LambdaClass Blog
We interview the team developing Iroh, a Rust peer-to-peer library that just works.| LambdaClass Blog
Introduction An interactive proof is a protocol between two parties, a prover $\mathcal{P}$ and a verifier $\mathcal{V}$, where the prover attempts to convince the verifier of the validity of a statement. By leveraging randomness and interaction, the verifier can check the statement more efficiently than by doing everything| LambdaClass Blog
Introduction Elliptic curves (EC) have gained widespread acceptance as tools for cryptography. They offer several advantages over other methods, such as RSA, providing equal levels of security with shorter keys (for example, 228-bit keys in EC cryptography are as good as 2300-bit RSA keys). This represents an advantage, since more| LambdaClass Blog
Introduction The ZEXE (Zero-knowledge EXEcution) protocol appeared in 2018, introducing the cryptographic primitive of decentralized private computation (DPC). It aims to solve two main drawbacks that decentralized ledgers suffer: privacy and scalability. Let's take the examples of Bitcoin and Ethereum. We see that the history of all transactions is public| LambdaClass Blog
Introduction Succinct Non-Interactive Arguments of Knowledge (SNARKs) are powerful cryptographic primitives with decentralized finances, governance, and computation applications. There are many different SNARKs, such as Marlin (the one Aleo uses), Plonk, STARKs, Groth16, etc., depending on the tools they are built on and with differences in performance, proof sizes, verification| LambdaClass Blog
On January 26th Starkware informed us that they had found a critical issue in the Cairo VM related to a program that would successfully execute on the VM but would violate the AIR constraints. A fix was already implemented in a PR, merged, and a release was made and deployed.| LambdaClass Blog
TL;DR: this post addresses the paper introducing rStar-Math and the techniques for smaller language models to outperform more complex large language models on math-related tasks. You can check the code here. rStar-Math significantly improved the math reasoning abilities of SLMs. For instance, on the MATH benchmark, it enhanced Qwen2.| LambdaClass Blog
Introduction In a previous post, we explained how to define constraints for a continuous read-only memory, presenting it as an example to understand how constraints are defined in general. This time, we will continue digging into this example to introduce the LogUp construction, adapted to univariate polynomials, and explain how| LambdaClass Blog
Why you should avoid having complex codebases and departing from standards when developing zero-knowledge virtual machines TL;DR: We found a subtle bug in Succinct's SP1 virtual machine, which allows a malicious user to prove the validity of false statements by subtly manipulating register 0 in the guest code This| LambdaClass Blog
TL;DR Training Large Language Models (LLM) with billions of parameters is computationally intensive and involves large communication in specialized data centers. Nous Research released DeMo, showing how to reduce these communication costs by orders of magnitude, decreasing costs and enabling training with poorer connections and less expensive hardware. This| LambdaClass Blog
Introduction When we first explored the world of STARKs, one of the most confusing concepts we encountered was constraints. We kept asking ourselves: How is it possible to summarize highly complex relationships between trace values using just a few polynomials? It wasn’t until we started implementing some examples that| LambdaClass Blog
Introduction It has been over a year and a half since we launched lambdaworks, our cryptography library for zero-knowledge (ZK) proofs. We built it focusing on performance, ease of use, support for hardware acceleration, and teaching others how to develop and understand ZK. Several advances in ZK in the last| LambdaClass Blog
Introduction The elliptic curve BN254 is currently the only curve with precompiled contracts on Ethereum, making it the most practical choice of a pairing-friendly curve suitable for on-chain zk-SNARK verification with proof systems such as Groth16 and PlonK. This work arises from the need to have our own implementation of| LambdaClass Blog
For the past few weeks we have been working on a reimplementation of ZKsync's (out of circuit) EraVM. The goal is to improve on its current performance and explore the possibility of adding parallel execution through BlockSTM. For that, we first had to make a deep dive into how the| LambdaClass Blog
1. Introduction 1.1 Motivation Imagine you want to do a complex computation, that you cannot carry out in your computer, or you need to get the results from a computer that you don't trust. How can you be sure it was done correctly without redoing it yourself or understanding| LambdaClass Blog
Introduction Scalable, transparent arguments of knowledge (STARKs) have gained widespread attention due to their applications in verifiable computing and blockchain scalability. We can use STARKs to generate a short string that attests to the integrity of a computation and a verifier can verify it very fast. The steps to generate| LambdaClass Blog
We implemented 75% of the functionality of the Ethereum Virtual Machine, in two weeks, with five new hires, compiling the VM opcode logic to native machine code with a state of the art compiler backend. Why did we do this? How? The TL;DR is: to get a performance boost| LambdaClass Blog
Introduction Zero-knowledge and validity proofs have gained attention due to their capabilities in decentralized private computation, scaling blockchains, identity protocols, and verifiable machine learning, among others. They allow one party, the prover, to show to other parties, the verifiers, that a given statement is true in a time- and memory-efficient| LambdaClass Blog
Proof aggregation techniques Introduction SNARKs (succinct, non-interactive arguments of knowledge) and STARKs (scalable, transparent arguments of knowledge) have gained widespread attention due to their applications in decentralized private computation and scaling blockchains. They are tools that allow us to prove to another party that we did a computation correctly so| LambdaClass Blog
At LambdaClass, benchmarks and performance analysis are critical aspects of our development process. We always perform performance analysis in every PR via our CI pipelines to spot any performance issues. The Cairo virtual machine is not an exception since it is a core part of the Starknet network. In this| LambdaClass Blog
Introduction We started with an internal bootcamp two weeks ago to onboard new engineers to our team. We wanted to give the basic building blocks in cryptography and also an introduction to zero-knowledge proofs (ZKP) using lambdaworks. Zero-knowledge proofs are a powerful technology that could shape the future in many| LambdaClass Blog
Zero-knowledge, Succinct, Non-interactive ARguments of Knowledge (zk-SNARKs) are powerful cryptographic primitives that allow one party, the prover, to convince another party, the verifier, that a given statement is true without revealing anything else other than the validity of the statement. They have gained widespread attention due to their applications in| LambdaClass Blog
Introduction lambdaworks is a library designed to provide efficient proof systems. We want it to support state of the art provers and associated primitives so that people can use them to build new applications. Among those primitives we have polynomial commitment schemes (PCS). These are a powerful cryptographic tool that| LambdaClass Blog
Introduction During the last few months, we have been developing a bridge between Mina and Ethereum. Mina is a layer-1 blockchain that uses zero-knowledge proofs (zk-SNARKs) to maintain its size at 22 kB. The bridge serves two purposes: 1. Allowing cross-chain transactions seamlessly. 2. Allowing applications to leverage Mina's zero-knowledge| LambdaClass Blog
Introduction During the last months, we have been working to make Lambdaworks STARK Platinum prover with Starknet's Stone prover. We also want STARK Platinum to be flexible enough to be used as a drop-in replacement for other STARK provers, such as Winterfell (employed as the default prover in Miden). One| LambdaClass Blog
Introduction STARKs (scalable transparent arguments of knowledge) have gained widespread attention due to their ability to help scale Ethereum. They allow one party, the prover, to show to a verifier that a given program execution is correct by submitting proof that can be verified much faster than naïve re-execution by| LambdaClass Blog
Introduction In this series of blog posts, we will see how Lambdaworks is implemented and the standard tools needed to develop provers. This first part will briefly overview the library and then focus on the finite field design and usage. Lambdaworks at its core is a library to create proving| LambdaClass Blog
Introduction Lambdaworks is our library for finite fields, elliptic curves, and proof systems. Among them, we have a STARK, Plonk, Groth 16 provers and we are on the way to having a fully compatible Cairo prover using STARKs. We want to continue adding new proof systems and polynomial commitment schemes| LambdaClass Blog
Introduction Zero-knowledge and validity proofs, often abbreviated as ZK, represent a fascinating field within the realms of cryptography, mathematics, and computer science. They allow one party, the prover, to convince other parties, termed verifiers, that a specific statement (such as the execution of a computer program) is true in a| LambdaClass Blog
Introduction ZK-SNARKs (zero-knowledge, succinct, non-interactive arguments of knowledge) and STARKs (scalable, transparent arguments of knowledge) have gained widespread attention due to their applications in distributed private computing and blockchain scaling. Over the years, we have seen several performance improvements thanks to new proof systems, new lookup arguments, and smaller fields.| LambdaClass Blog
Introduction One of the current goals is to realize, in an efficient way, incrementally verifiable computation (IVC). This cryptographic primitive allows a given party to show the integrity of a given computer program's execution by providing proof that the result of each step is correct and that all previous ones| LambdaClass Blog
Introduction When working with cryptographic applications you need to understand some of the underlying math (at least, if you want to do things properly). For example, the RSA cryptographic system (which was one of the earliest methods and most widely adopted, until it lost ground to better methods, such as| LambdaClass Blog
Introduction ZK-SNARKs (zero-knowledge succinct, non-interactive arguments of knowledge) and STARKs (scalable transparent arguments of knowledge) are powerful cryptographic constructions with applications in decentralized private computing and blockchain scaling. They allow one party, the prover, to show that he carried a computation correctly to a second party, the verifier, in a| LambdaClass Blog
Introduction There has recently been a growing interest in zk-SNARKs (zero-knowledge, succinct, non-interactive arguments of knowledge) due to their capabilities in decentralized private computations and scaling blockchains. These constructions involve a protocol between two parties, a prover and a verifier, where the former attempts to convince the latter of the| LambdaClass Blog
Introduction Over the last decade, SNARKs (succinct, non-interactive arguments of knowledge) and STARKs (scalable, transparent arguments of knowledge) have been gaining attention due to their applications in verifiable private computation and scalability of blockchains. Groth introduced this proof system in 2016 and saw an early application in ZCash. The protocol| LambdaClass Blog
Introduction About one month ago, Starkware open-sourced its Stone Prover, which is currently in production in Starknet. It is a library that allows one to produce proofs of computational integrity using STARKs (Scalable Transparent Arguments of Knowledge). The codebase has around 100k lines of code, written mainly in C++. It| LambdaClass Blog
In this blogpost, we'll take a closer look at the Inner Product Argument. We'll start by understanding the basics of this technique and then shift our focus to its variant within the Halo2 proving system. Specifically, we'll explore how Halo2 ingeniously employs the Inner Product Argument as a polynomial commitment| LambdaClass Blog
Introduction STARKs (scalable transparent arguments of knowledge) have gained a lot of attention in recent years due to their capacity to help scale Ethereum and other L1s. They provide a way to guarantee the integrity of a computation carried out by an untrusted party via cryptographic proof. This proof can| LambdaClass Blog
Introduction Zero-knowledge proofs, also known as ZKPs, are becoming popular due to their numerous applications in delegating computations to untrusted servers and addressing scalability issues in decentralized ledgers. By using ZKPs, we can prove the validity of a given computation without revealing sensitive information, and the proof is short and| LambdaClass Blog
Introduction From July 14th to 16th, we organized, together with Ingonyama, the first Lambda-Ingo ZK capture the flag (CTF), where more than 60 teams and 160 people participated. The CTF involved several challenges related to zero-knowledge proofs (using Lambdaworks) and fully-homomorphic encryption. We are thrilled with the whole experience, especially| LambdaClass Blog