Introduction

Sirius, renowned as the most luminous star in the night sky, deceives the naked eye by appearing as a solitary point of light when, in fact, it is a binary star system. Inspired by this duality, our project bears the name Sirius, capturing the essence of folded instances that give the illusion of being a singular entity.

Introduction

Sirius is an open-source constraint-system-agnostic folding framework for Incrementally Verifiable Computation [IVC].

Within the context of an IVC scheme, the prover's role is to demonstrate that, upon consecutively applying a step function F exactly n times to an initial value $z_0$, the result is $z_n$. Here, the step function F takes two inputs $z_i$ and $w$, and yields an output $z_{i+1}$.

Architecture

The Sirius folding framework is designed with a three-tiered architecture.

• Frontend Layer: This layer serves as the interface for various constraint systems, including Plonk, R1CS, and AIR. It's engineered to allow developers to work with their preferred constraint systems. User-defined circuits and witness data are converted into an intermediate representation format defined by the folding scheme. Our current implementation follows the Special-sound interactive protocol [SPS]. An alternative scheme would be the Customizable Constraint Systems protocol [CCS].

• Folding Scheme Layer: At the heart of the framework are the folding schemes IVC that accumulate the computations of multiple steps. At each step, the prover first calculates the instance-witness pairs from the previous step and folds them into the accumulator, then computes the cross terms and error vector for the folded instance-witness pairs. An IVC circuit then takes the outputs from the prover and performs the following steps: apply the step function F, fold the previous step's instance into the accumulator instance, and verify the inputs of the IVC circuit.

• Backend Layer: The backend leverages Polynomial Interactive Oracle Proofs (PIOP) and Polynomial Commitment Schemes (PCS) to generate zkSNARKs for succinct and zero-knowledge verification. Polynomial relation checks of the IVC decider are converted to the multi-variate sum-check protocol. The evaluation phase of the sum-check protocol depends on the polynomial commitment scheme we choose (e.g. Hyrax). It is worth noting that when the polynomials are sparse, we can use the Spark compiler [Spartan] to handle them efficiently.

Roadmap

• 2023Q4 - halo2 frontend support

• 2023Q4 - folding scheme for Plonkish custom gates

• 2023Q4 - IVC circuit

• 2023Q4 - folding scheme for lookup arguments

• 2024Q1 - high-degree gate optimization from Protostar

• 2024Q2 - IOP+PCS backend support (Spartan / Hyperplonk)

• 2024Q3 - on-chain verifier support

The estimated timeline is subject to change.

Getting Involved

If you're as enthusiastic about Sirius as we are, we invite you to join our developer community at Telegram. It's a great place to stay updated, get involved, and contribute to the project. Whether you're looking to contribute code, provide feedback, or simply stay in the loop, our Telegram group is the place to be.

👉 Join our developer community

Thank you for your interest in contributing to Sirius! ✨