feat: cyclefold trivial example

Cargo.toml

@@ -63,11 +63,11 @@ default-features = false
 features = ["prepush-hook", "run-cargo-fmt", "run-cargo-test", "run-cargo-clippy"]
 
 [[bench]]
-name = "trivial"
+name = "sangria_trivial"
 harness = false
 
 [[bench]]
-name = "poseidon"
+name = "sangria_poseidon"
 harness = false
 
 [features]

benches/cyclefold_poseidon/main.rs

@@ -0,0 +1,151 @@
+use std::{array, io, marker::PhantomData, path::Path};
+
+use bn256::G1 as C1;
+use criterion::{criterion_group, Criterion};
+use metadata::LevelFilter;
+use sirius::{
+    commitment::CommitmentKey,
+    ff::{Field, FromUniformBytes, PrimeFieldBits},
+    group::Group,
+    halo2_proofs::{
+        circuit::{AssignedCell, Layouter},
+        plonk::ConstraintSystem,
+    },
+    halo2curves::{bn256, grumpkin, CurveAffine},
+    ivc::{
+        cyclefold::{PublicParams, IVC},
+        StepCircuit, SynthesisError,
+    },
+    main_gate::{MainGate, MainGateConfig, RegionCtx, WrapValue},
+    poseidon::{poseidon_circuit::PoseidonChip, Spec},
+};
+use tracing::*;
+use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
+
+const ARITY: usize = 1;
+
+const CIRCUIT_TABLE_SIZE1: usize = 17;
+const COMMITMENT_KEY_SIZE: usize = 21;
+
+// Spec for user defined poseidon circuit
+const T1: usize = 3;
+const RATE1: usize = 2;
+const R_F1: usize = 4;
+const R_P1: usize = 3;
+
+#[derive(Clone, Debug)]
+struct TestPoseidonCircuitConfig {
+    pconfig: MainGateConfig<T1>,
+}
+
+#[derive(Default, Debug, Clone)]
+struct TestPoseidonCircuit<F: PrimeFieldBits> {
+    _p: PhantomData<F>,
+}
+
+impl<F: PrimeFieldBits + FromUniformBytes<64>> StepCircuit<ARITY, F> for TestPoseidonCircuit<F> {
+    type Config = TestPoseidonCircuitConfig;
+
+    fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
+        let pconfig = MainGate::configure(meta);
+        Self::Config { pconfig }
+    }
+
+    fn synthesize_step(
+        &self,
+        config: Self::Config,
+        layouter: &mut impl Layouter<F>,
+        z_in: &[AssignedCell<F, F>; ARITY],
+    ) -> Result<[AssignedCell<F, F>; ARITY], SynthesisError> {
+        let spec = Spec::<F, T1, RATE1>::new(R_F1, R_P1);
+        let mut pchip = PoseidonChip::new(config.pconfig, spec);
+        let input = z_in.iter().map(|x| x.into()).collect::<Vec<WrapValue<F>>>();
+        pchip.update(&input);
+        let output = layouter
+            .assign_region(
+                || "poseidon hash",
+                |region| {
+                    let ctx = &mut RegionCtx::new(region, 0);
+                    pchip.squeeze(ctx)
+                },
+            )
+            .map_err(SynthesisError::Halo2)?;
+        Ok([output])
+    }
+}
+
+type C1Scalar = <C1 as Group>::Scalar;
+
+const FOLDER: &str = ".cache/examples";
+
+#[instrument]
+fn get_or_create_commitment_key<C: CurveAffine>(
+    k: usize,
+    label: &'static str,
+) -> io::Result<CommitmentKey<C>> {
+    unsafe { CommitmentKey::load_or_setup_cache(Path::new(FOLDER), label, k) }
+}
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let _span = info_span!("poseidon_bench").entered();
+    let prepare_span = info_span!("prepare").entered();
+
+    // C1
+    let sc1 = TestPoseidonCircuit::default();
+
+    let primary_commitment_key =
+        get_or_create_commitment_key::<bn256::G1Affine>(COMMITMENT_KEY_SIZE, "bn256")
+            .expect("Failed to get secondary key");
+    let secondary_commitment_key =
+        get_or_create_commitment_key::<grumpkin::G1Affine>(COMMITMENT_KEY_SIZE, "grumpkin")
+            .expect("Failed to get primary key");
+
+    let mut pp = PublicParams::new(
+        &sc1,
+        primary_commitment_key,
+        secondary_commitment_key,
+        CIRCUIT_TABLE_SIZE1 as u32,
+    )
+    .unwrap();
+
+    prepare_span.exit();
+
+    let mut group = c.benchmark_group("ivc_of_poseidon");
+    group.significance_level(0.1).sample_size(10);
+
+    group.bench_function("fold_1_step", |b| {
+        let mut rnd = rand::thread_rng();
+        let primary_z_0 = array::from_fn(|_| C1Scalar::random(&mut rnd));
+
+        b.iter(|| {
+            IVC::new(&mut pp, &sc1, primary_z_0)
+                .expect("while step=0")
+                .next(&pp, &sc1)
+                .expect("while step=1")
+                .verify(&pp)
+                .expect("while verify");
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+
+fn main() {
+    tracing_subscriber::fmt()
+        .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(LevelFilter::INFO.into())
+                .from_env_lossy(),
+        )
+        .json()
+        .init();
+
+    benches();
+
+    criterion::Criterion::default()
+        .configure_from_args()
+        .final_summary();
+}

benches/poseidon/main.rs → benches/sangria_poseidon/main.rs

@@ -13,7 +13,10 @@ use sirius::{
         plonk::ConstraintSystem,
     },
     halo2curves::{bn256, grumpkin, CurveAffine, CurveExt},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, StepCircuit, SynthesisError, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit, StepCircuit, SynthesisError,
+    },
     main_gate::{MainGate, MainGateConfig, RegionCtx, WrapValue},
     poseidon::{self, poseidon_circuit::PoseidonChip, ROPair, Spec},
 };

benches/trivial/main.rs → benches/sangria_trivial/main.rs

@@ -11,7 +11,10 @@ use sirius::{
     ff::Field,
     group::{prime::PrimeCurve, Group},
     halo2curves::{bn256, grumpkin, CurveAffine, CurveExt},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams},
+        step_circuit, SangriaIVC,
+    },
     poseidon::{self, ROPair},
 };
 use tracing::*;
@@ -109,7 +112,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         let secondary_z_0 = array::from_fn(|_| C2Scalar::random(&mut rnd));
 
         b.iter(|| {
-            IVC::fold(
+            SangriaIVC::fold(
                 &pp,
                 &sc1,
                 black_box(primary_z_0),
@@ -127,7 +130,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         let secondary_z_0 = array::from_fn(|_| C2Scalar::random(&mut rnd));
 
         b.iter(|| {
-            IVC::fold(
+            SangriaIVC::fold(
                 &pp,
                 &sc1,
                 black_box(primary_z_0),

examples/cli.rs

@@ -15,7 +15,11 @@ use halo2_proofs::halo2curves;
 use poseidon::poseidon_step_circuit::TestPoseidonCircuit;
 use sirius::{
     ff::{FromUniformBytes, PrimeField, PrimeFieldBits},
-    ivc::{step_circuit::trivial, CircuitPublicParamsInput, PublicParams, StepCircuit, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit::trivial,
+        StepCircuit,
+    },
     poseidon::ROPair,
 };
 use tracing::*;

examples/cyclefold_trivial/main.rs

@@ -0,0 +1,63 @@
+use std::{array, path::Path};
+
+use sirius::{commitment::CommitmentKey, ff::Field, ivc::step_circuit::trivial};
+
+/// Arity : Input/output size per fold-step for primary step-circuit
+/// For tivial case it can be any number
+const A1: usize = 5;
+
+/// Key size for Primary Circuit
+const PRIMARY_COMMITMENT_KEY_SIZE: usize = 23;
+
+/// Table size for Primary Circuit
+///
+/// Requires at least 17, for service purposes, but if the primary requires more, increase the
+/// constant
+const PRIMARY_CIRCUIT_TABLE_SIZE: usize = 20;
+
+/// Key size for Primary Circuit
+const SECONDARY_COMMITMENT_KEY_SIZE: usize = 23;
+
+use sirius::cyclefold_prelude::{
+    bn256::{C1Affine, C1Scalar, C2Affine},
+    PublicParams, IVC,
+};
+
+const FOLDER: &str = ".cache/examples";
+
+fn main() {
+    let sc = trivial::Circuit::<A1, C1Scalar>::default();
+
+    let primary_commitment_key = unsafe {
+        CommitmentKey::<C1Affine>::load_or_setup_cache(
+            Path::new(FOLDER),
+            "bn256",
+            PRIMARY_COMMITMENT_KEY_SIZE,
+        )
+        .unwrap()
+    };
+
+    let secondary_commitment_key = unsafe {
+        CommitmentKey::<C2Affine>::load_or_setup_cache(
+            Path::new(FOLDER),
+            "grumpkin",
+            SECONDARY_COMMITMENT_KEY_SIZE,
+        )
+        .unwrap()
+    };
+
+    let mut pp = PublicParams::new(
+        &sc,
+        primary_commitment_key,
+        secondary_commitment_key,
+        PRIMARY_CIRCUIT_TABLE_SIZE as u32,
+    )
+    .unwrap();
+
+    IVC::new(&mut pp, &sc, array::from_fn(|_| C1Scalar::ZERO))
+        .expect("while step=0")
+        .next(&pp, &sc)
+        .expect("while step=1")
+        .verify(&pp)
+        .expect("while verify");
+}

examples/instances.rs

@@ -10,9 +10,9 @@ use sirius::{
         step_circuit::{trivial, AssignedCell, ConstraintSystem, Layouter},
         SynthesisError,
     },
-    prelude::{
+    sangria_prelude::{
         bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar},
-        CommitmentKey, PrimeField, StepCircuit, IVC,
+        CommitmentKey, PrimeField, SangriaIVC, StepCircuit,
     },
 };
 use tracing::debug;
@@ -155,7 +155,7 @@ fn main() {
         &sc2,
     );
 
-    IVC::fold_with_debug_mode(
+    SangriaIVC::fold_with_debug_mode(
         &pp,
         &sc1,
         array::from_fn(|i| C1Scalar::from(i as u64)),

examples/merkle/main.rs

@@ -27,7 +27,10 @@ mod sirius_mod {
         commitment::CommitmentKey,
         ff::Field,
         group::{prime::PrimeCurve, Group},
-        ivc::{step_circuit::trivial, CircuitPublicParamsInput, PublicParams, IVC},
+        ivc::{
+            sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+            step_circuit::trivial,
+        },
     };
     use tracing::info_span;
 

examples/my_circuit.rs

@@ -5,9 +5,9 @@ use sirius::{
         step_circuit::{trivial, AssignedCell, ConstraintSystem, Layouter},
         SynthesisError,
     },
-    prelude::{
+    sangria_prelude::{
         bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar},
-        CommitmentKey, PrimeField, StepCircuit, IVC,
+        CommitmentKey, PrimeField, SangriaIVC, StepCircuit,
     },
 };
 
@@ -87,7 +87,7 @@ fn main() {
         &sc2,
     );
 
-    IVC::fold_with_debug_mode(
+    SangriaIVC::fold_with_debug_mode(
         &pp,
         &sc1,
         array::from_fn(|i| C1Scalar::from(i as u64)),

examples/poseidon.rs

@@ -127,7 +127,10 @@ use sirius::{
     commitment::CommitmentKey,
     group::{prime::PrimeCurve, Group},
     halo2curves::{bn256, grumpkin, CurveAffine},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit,
+    },
     poseidon::{self, ROPair},
 };
 use tracing::*;

examples/trivial/main.rs → examples/sangria_trivial/main.rs

@@ -2,7 +2,7 @@ use std::{array, num::NonZeroUsize};
 
 use sirius::{
     commitment::CommitmentKey,
-    ivc::{step_circuit::trivial, IVC},
+    ivc::{step_circuit::trivial, SangriaIVC},
 };
 
 /// Arity : Input/output size per fold-step for primary step-circuit
@@ -31,7 +31,7 @@ const PRIMARY_CIRCUIT_TABLE_SIZE: usize = 17;
 /// Key size for Primary Circuit
 const SECONDARY_COMMITMENT_KEY_SIZE: usize = 21;
 
-use sirius::prelude::bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar};
+use sirius::sangria_prelude::bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar};
 
 fn main() {
     let sc1 = trivial::Circuit::<A1, C1Scalar>::default();
@@ -52,7 +52,7 @@ fn main() {
         &sc2,
     );
 
-    IVC::fold_with_debug_mode(
+    SangriaIVC::fold_with_debug_mode(
         &pp,
         &sc1,
         array::from_fn(|i| C1Scalar::from(i as u64)),

examples/sha256/main.rs

@@ -13,7 +13,10 @@ use sirius::{
     ff::PrimeField,
     group::{prime::PrimeCurve, Group},
     halo2curves::{bn256, grumpkin, CurveAffine, CurveExt},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, StepCircuit, SynthesisError, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit, StepCircuit, SynthesisError,
+    },
     poseidon::{self, ROPair},
 };
 use tracing::*;

rust-toolchain.toml

@@ -1 +1 @@
-toolchain.channel = "1.83.0"
+toolchain.channel = "1.84.0"