tests custom gates

plonky2/src/batch_fri/oracle.rs

@@ -460,7 +460,7 @@ mod test {
             &fri_instances,
             &fri_openings,
             &fri_challenges,
-            &[merkle_cap.clone()],
+            std::slice::from_ref(&merkle_cap),
             &proof,
             &fri_params,
         )?;

plonky2/src/fri/validate_shape.rs

@@ -20,7 +20,7 @@ where
     F: RichField + Extendable<D>,
     C: GenericConfig<D, F = F>,
 {
-    validate_batch_fri_proof_shape::<F, C, D>(proof, &[instance.clone()], params)
+    validate_batch_fri_proof_shape::<F, C, D>(proof, std::slice::from_ref(instance), params)
 }
 
 pub(crate) fn validate_batch_fri_proof_shape<F, C, const D: usize>(

plonky2/src/gates/addition_base.rs

@@ -1,7 +1,5 @@
 extern crate alloc;
 use alloc::string::ToString;
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
 
 use anyhow::Result;
 
@@ -242,12 +240,20 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
+    use plonky2_field::types::Sample;
 
     use crate::field::goldilocks_field::GoldilocksField;
+    use crate::field::types::Field;
+    #[allow(unused_imports)]
+    use crate::field::types::Field64;
     use crate::gates::addition_base::AdditionGate;
     use crate::gates::gate_testing::{test_eval_fns, test_low_degree};
-    use crate::plonk::circuit_data::CircuitConfig;
+    use crate::iop::target::Target;
+    use crate::iop::witness::{PartialWitness, WitnessWrite};
+    use crate::plonk::circuit_builder::CircuitBuilder;
+    use crate::plonk::circuit_data::{CircuitConfig, CircuitData};
     use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
+    use crate::util::serialization::{DefaultGateSerializer, DefaultGeneratorSerializer};
 
     #[test]
     fn low_degree() {
@@ -263,4 +269,199 @@ mod tests {
         let gate = AdditionGate::new_from_config(&CircuitConfig::standard_recursion_config());
         test_eval_fns::<F, C, _, D>(gate)
     }
+
+    #[test]
+    fn test_success() -> Result<()> {
+        const D: usize = 2;
+        type C = PoseidonGoldilocksConfig;
+        type F = <C as GenericConfig<D>>::F;
+
+        fn flag_test(flag: usize) -> Result<()> {
+            let config = CircuitConfig {
+                optimization_flags: flag,
+                ..CircuitConfig::standard_recursion_config()
+            };
+            let mut builder = CircuitBuilder::<F, D>::new(config.clone());
+
+            let mut pairs = vec![];
+
+            let gate = AdditionGate::new_from_config(&config);
+            let constants = [F::ONE, F::ONE];
+
+            for _ in 0..100 {
+                let x = builder.add_virtual_target();
+                let y = builder.add_virtual_target();
+                let output_value = builder.add_virtual_target();
+
+                let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants);
+
+                let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i));
+                let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i));
+                let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i));
+
+                builder.connect(x, wire_x);
+                builder.connect(y, wire_y);
+                builder.connect(output_value, wire_output);
+
+                pairs.push((x, y, output_value));
+            }
+
+            let circuit_data = builder.build::<C>();
+
+            let mut pw = PartialWitness::new();
+            for (x, y, output_value) in pairs.iter() {
+                let value1 = F::rand();
+                let value2 = F::rand();
+                let expected = value1 + value2;
+                pw.set_target(*x, value1)?;
+                pw.set_target(*y, value2)?;
+                pw.set_target(*output_value, expected)?;
+            }
+
+            let proof = circuit_data.prove(pw)?;
+            circuit_data.verify(proof)?;
+
+            Ok(())
+        }
+
+        flag_test(63)?; // flag enabled
+        flag_test(62)?; // flag disabled
+
+        Ok(())
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_failure() {
+        const D: usize = 2;
+        type C = PoseidonGoldilocksConfig;
+        type F = <C as GenericConfig<D>>::F;
+
+        fn flag_test(flag: usize) {
+            let config = CircuitConfig {
+                optimization_flags: flag,
+                ..CircuitConfig::standard_recursion_config()
+            };
+            let mut builder = CircuitBuilder::<F, D>::new(config.clone());
+
+            let mut pairs = vec![];
+
+            let gate = AdditionGate::new_from_config(&config);
+            let constants = [F::ONE, F::ONE];
+
+            for _ in 0..100 {
+                let x = builder.add_virtual_target();
+                let y = builder.add_virtual_target();
+                let output_value = builder.add_virtual_target();
+
+                let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants);
+
+                let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i));
+                let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i));
+                let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i));
+
+                builder.connect(x, wire_x);
+                builder.connect(y, wire_y);
+                builder.connect(output_value, wire_output);
+
+                pairs.push((x, y, output_value));
+            }
+
+            let circuit_data = builder.build::<C>();
+
+            let mut pw = PartialWitness::new();
+            for (x, y, output_value) in pairs.iter() {
+                let value1 = F::rand();
+                let value2 = F::rand();
+                let expected = value1 + value2;
+                let mut incorrect_value = F::rand();
+                while incorrect_value == expected {
+                    incorrect_value = F::rand();
+                }
+                pw.set_target(*x, value1).unwrap();
+                pw.set_target(*y, value2).unwrap();
+                pw.set_target(*output_value, incorrect_value).unwrap();
+            }
+
+            let proof = circuit_data.prove(pw).unwrap();
+            circuit_data.verify(proof).unwrap();
+        }
+
+        flag_test(63); // flag enabled
+        flag_test(62); // flag disabled
+    }
+
+    #[test]
+    fn test_serialization_addition() -> Result<()> {
+        const D: usize = 2;
+        type C = PoseidonGoldilocksConfig;
+        type F = <C as GenericConfig<D>>::F;
+
+        let config = CircuitConfig::standard_recursion_config();
+        let mut builder = CircuitBuilder::<F, D>::new(config.clone());
+
+        let mut pairs = vec![];
+
+        let gate = AdditionGate::new_from_config(&config);
+        let constants = [F::ONE, F::ONE];
+
+        for _ in 0..100 {
+            let x = builder.add_virtual_target();
+            let y = builder.add_virtual_target();
+            let output_value = builder.add_virtual_target();
+
+            let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants);
+
+            let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i));
+            let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i));
+            let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i));
+
+            builder.connect(x, wire_x);
+            builder.connect(y, wire_y);
+            builder.connect(output_value, wire_output);
+
+            pairs.push((x, y, output_value));
+        }
+
+        let circuit_data = builder.build::<C>();
+        // let filename = "test_circuit";
+        let gate_serializer = DefaultGateSerializer;
+        let generator_serializer = DefaultGeneratorSerializer::<C, D>::default();
+
+        let data_bytes = circuit_data
+            .to_bytes(&gate_serializer, &generator_serializer)
+            .map_err(|_| anyhow::Error::msg("Serialization failed."))?;
+
+        // fs::write(filename, &data_bytes)?;
+
+        // let read_data_bytes = fs::read(filename)?;
+
+        let deserialized_circuit_data = CircuitData::<F, C, D>::from_bytes(
+            &data_bytes,
+            &gate_serializer,
+            &generator_serializer,
+        )
+        .map_err(|_| anyhow::Error::msg("Deserialization failed."))?;
+
+        assert_eq!(deserialized_circuit_data, circuit_data);
+
+        let mut pw = PartialWitness::new();
+
+        for (x, y, output_value) in pairs.iter() {
+            let value1 = F::rand();
+            let value2 = F::rand();
+            let expected = value1 + value2;
+
+            pw.set_target(*x, value1)?;
+            pw.set_target(*y, value2)?;
+            pw.set_target(*output_value, expected)?;
+        }
+
+        let proof = deserialized_circuit_data.prove(pw.clone())?;
+        deserialized_circuit_data.verify(proof.clone())?;
+
+        // std::fs::remove_file(filename)?;
+
+        Ok(())
+    }
 }