Dynamic zk-SNARKs: Lagrange's Breakthrough in Verifiable AI

The promise of zero-knowledge proofs has always been to make trust programmable. In a world where data and computation are constantly evolving, static proof systems no longer suffice. As the AI models that power our systems retrain, iterate, and evolve on changing datasets, the need for updatable cryptographic proofs becomes crucial. 

This is where Dynamic zk‑SNARKs—developed by the Lagrange research team (Wang, Papamanthou, Srinivasan & Papadopoulos, IACR 2024/1566)—break new ground. For the first time, we can efficiently update zk‑SNARK proofs when the underlying data changes without starting over from scratch. Dynamic zk-SNARKS unlock a new class of verifiable systems with proofs that evolve as fast as the systems they verify. 

Since day one, real-world impact has remained a north star for the Lagrange research team. Dynamic zk‑SNARKs aren’t just theoretical, they’re a critical piece of the infrastructure needed to make AI safe, verifiable, and trustworthy. With this research, we can deploy AI in safety-critical environments where speed, adaptability, and provable trust are non-negotiables.

Lagrange’s “Dynamic zk‑SNARKs” is one of the only papers from a blockchain team accepted to the Science of Blockchain Conference (SBC) 2025. Dynamic zk-SNARKS will be presented and livestreamed at SBC on August 4, 2025. This marks Lagrange’s second research paper in three years to be featured at SBC, following the acceptance of Reckle Trees in 2023 (now a patented research mechanism).

From Static to Dynamic: A Shift in Possibility

Historically, zk‑SNARKs like Groth16, Plonk, and Marlin have been dominated by schemes designed for static data. These traditional zk-SNARKs excel at proving the knowledge of a witness for a fixed statement, but falter when real-world applications require agile performance. Every time the underlying data shifts, the zk-SNARK rebuilds a fresh proof. While reliable, such an approach becomes both inefficient and expensive when a dataset or computation evolves incrementally (as in AI models, gaming state machines, or blockchain oracles).

Dynamic zk‑SNARKs break through these limitations, introducing an updateable SNARK paradigm: given an original proof for a statement, you can incrementally update it, so long as the change is small (e.g. small Hamming distance). Imagine updating a receipt instead of printing a new one every time a customer adds an item—dynamic zk-SNARKs are faster, cheaper and smarter for data-intensive apps.

Building Blocks: From Dynamo to Dynalog

The transition from static to dynamic hinges on three core constructions:

1. Dynamo: A SNARK tailored for relaxed permutation relations. Instead of checking a full permutation relation, it efficiently verifies that a committed vector is almost a permutation of another. This becomes a foundation for dynamic updates in general permutation arguments.
2. Dynaverse: Leverages the decomposition of witness vectors for both gate constraints and the permutation relation. Updates occur in O(\sqrt{n} \cdot \log n) time, yet preserve constant-size proofs by using a static zk-SNARK—remarkably efficient when edits are structured.
3. Dynalog: Introduces a hierarchical data structure built from exponentially scaling buckets to achieve dynamic proofs for gate constraints. Together with Dynamo for the relaxed permutation relation at each bucket, it achieves polylogarithmic update time and proof sizes. This is milestone-level performance: efficient updates for massive datasets.

It is important to note that the underlying security of the zk-SNARK remains robust. Dynamic zk-SNARKs rely on the q-DLOG assumption in the Algebraic Group Model (the same bedrock as Groth16).

The Lagrange Vision: From Theory to Products

Dynamic zk‑SNARKs are more than a research milestone. They’re part of a broader strategy to build a ZK Prover Network capable of supporting real-time, updateable proofs for AI, blockchains, and beyond.

We can now realize provers that:

• Stream data—like oracles or ML pipelines—without reconstructing full proofs.
• Enable proof hooks in smart contracts that only re-verify changed portions.
• Remove inefficiencies in ZK pipelines (no need to “rewrite the receipt” for every small change).

This shift turns zk‑SNARKs from static validators into live assurance engines, enabling Lagrange to pioneer ZK architectures primed for the demands of key sectors, including AI.

Dynamic Proofs for Safe AI

At Lagrange, we envision a world where AI systems are not only powerful, but provably safe. Lagrange’s DeepProve enables the cryptographic verification of AI inferences with zero‑knowledge proofs, verifying properties like dataset integrity, model provenance, or compliance with regulatory constraints without exposing sensitive data.

Dynamic zk‑SNARKs take this paradigm one step further. They allow us to cryptographically validate AI systems as they evolve:

• When an AI model retrains on new data, we can update proofs incrementally (rather than recomputing from scratch).
• As weights shift during fine-tuning, we can preserve trust guarantees without inhibiting deployment.
• In live-learning systems, we can continuously prove properties of accuracy, safety, and alignment in real-time.

Together, DeepProve and Dynamic zk‑SNARKs form the foundation for real-time AI verification, ensuring that proofs of correctness, fairness, and integrity evolve in tandem with the models themselves. This innovation is essential for deploying AI in critical contexts such as autonomous vehicles, decentralized defense, and adaptive healthcare. By enabling proofs that evolve with their systems, we are closing the gap between cryptographic assurances and real-world innovations.

Pioneering the Future of Safe AI

Dynamic zk‑SNARKs redefine our ability to prove what is true. By introducing efficient proof updates, they unlock a new generation of cryptographic systems that are fast, scalable, and adaptive. In combination with DeepProve, they bring us closer to a world where AI, blockchains, and interactive applications can be provably safe—not just at launch, but throughout entire lifecycles.

‍