derive & implement Arbitrary for better property based testing

Cargo.toml

@@ -23,6 +23,7 @@ documentation = "https://triton-vm.org/spec/"
 
 [workspace.dependencies]
 anyhow = "1.0"
+arbitrary = { version = "1", features = ["derive"] }
 bincode = "1.3"
 colored = "2.0"
 criterion = { version = "0.5", features = ["html_reports"] }
@@ -35,6 +36,7 @@ num-traits = "0.2"
 prettyplease = "0.2"
 proc-macro2 = "1.0"
 proptest = "1.2"
+proptest-arbitrary-interop = "0.1"
 quote = "1.0"
 rand = "0.8.5"
 rand_core = "0.6.4"

triton-vm/Cargo.toml

@@ -19,6 +19,7 @@ readme.workspace = true
 
 [dependencies]
 anyhow.workspace = true
+arbitrary.workspace = true
 bincode.workspace = true
 colored.workspace = true
 criterion.workspace = true
@@ -43,6 +44,7 @@ unicode-width.workspace = true
 [dev-dependencies]
 cargo-husky.workspace = true
 proptest.workspace = true
+proptest-arbitrary-interop.workspace = true
 
 [[bench]]
 name = "prove_halt"

triton-vm/src/fri.rs

@@ -644,6 +644,7 @@ mod tests {
     use itertools::Itertools;
     use proptest::collection::vec;
     use proptest::prelude::*;
+    use proptest_arbitrary_interop::arb;
     use rand::prelude::IteratorRandom;
     use rand::prelude::StdRng;
     use rand_core::SeedableRng;
@@ -1081,4 +1082,14 @@ mod tests {
             _ => None,
         }
     }
+
+    proptest! {
+        #[test]
+        fn verifying_arbitrary_proof_does_not_panic(
+            fri in arbitrary_fri(),
+            mut proof_stream in arb::<ProofStream<Tip5>>(),
+        ) {
+            let _ = fri.verify(&mut proof_stream, &mut None);
+        }
+    }
 }

triton-vm/src/proof.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use arbitrary::Arbitrary;
 use get_size::GetSize;
 use itertools::Itertools;
 use serde::Deserialize;
@@ -13,7 +14,7 @@ use crate::stark;
 
 /// Contains the necessary cryptographic information to verify a computation.
 /// Should be used together with a [`Claim`].
-#[derive(Debug, Clone, GetSize, Serialize, Deserialize, PartialEq, Eq, BFieldCodec)]
+#[derive(Debug, Clone, GetSize, Serialize, Deserialize, PartialEq, Eq, BFieldCodec, Arbitrary)]
 pub struct Proof(pub Vec<BFieldElement>);
 
 impl Proof {
@@ -37,7 +38,9 @@ impl Proof {
 /// One additional piece of public information not explicitly listed in the [`Claim`] is the
 /// `padded_height`, an upper bound on the length of the computation.
 /// It is derivable from a [`Proof`] by calling [`Proof::padded_height()`].
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, GetSize, BFieldCodec, Hash)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, PartialEq, Eq, GetSize, BFieldCodec, Hash, Arbitrary,
+)]
 pub struct Claim {
     /// The hash digest of the program that was executed. The hash function in use is Tip5.
     pub program_digest: Digest,
@@ -65,12 +68,15 @@ impl Claim {
 
 #[cfg(test)]
 pub mod test_claim_proof {
+    use proptest::collection::vec;
+    use proptest::prelude::*;
     use rand::random;
     use twenty_first::shared_math::b_field_element::BFieldElement;
     use twenty_first::shared_math::bfield_codec::BFieldCodec;
     use twenty_first::shared_math::other::random_elements;
 
     use crate::proof_item::ProofItem;
+    use crate::shared_tests::arbitrary_bfield_element;
     use crate::stark::StarkHasher;
 
     use super::*;
@@ -121,4 +127,13 @@ pub mod test_claim_proof {
         let maybe_padded_height = proof.padded_height();
         assert!(maybe_padded_height.is_err());
     }
+
+    proptest! {
+        #[test]
+        fn decoding_arbitrary_proof_data_does_not_panic(
+            proof_data in vec(arbitrary_bfield_element(), 0..1000),
+        ) {
+            let _ = Proof::decode(&proof_data);
+        }
+    }
 }

triton-vm/src/proof_item.rs

@@ -1,5 +1,6 @@
 use anyhow::bail;
 use anyhow::Result;
+use arbitrary::Arbitrary;
 use strum_macros::Display;
 use strum_macros::EnumCount;
 use twenty_first::shared_math::b_field_element::BFieldElement;
@@ -13,15 +14,15 @@ use crate::stark::NUM_QUOTIENT_SEGMENTS;
 /// A `FriResponse` is an `AuthenticationStructure` together with the values of the
 /// revealed leaves of the Merkle tree. Together, they correspond to the
 /// queried indices of the FRI codeword (of that round).
-#[derive(Debug, Clone, PartialEq, Eq, Hash, BFieldCodec)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, BFieldCodec, Arbitrary)]
 pub struct FriResponse {
     /// The authentication structure of the Merkle tree.
     pub auth_structure: AuthenticationStructure,
     /// The values of the opened leaves of the Merkle tree.
     pub revealed_leaves: Vec<XFieldElement>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Display, EnumCount)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Display, EnumCount, Arbitrary)]
 pub enum ProofItem {
     AuthenticationStructure(AuthenticationStructure),
     MasterBaseTableRows(Vec<Vec<BFieldElement>>),
@@ -200,17 +201,6 @@ impl BFieldCodec for ProofItem {
     fn encode(&self) -> Vec<BFieldElement> {
         use ProofItem::*;
 
-        #[cfg(debug_assertions)]
-        {
-            use crate::table::master_table::NUM_BASE_COLUMNS;
-            use crate::table::master_table::NUM_EXT_COLUMNS;
-            match self {
-                OutOfDomainBaseRow(row) => assert_eq!(NUM_BASE_COLUMNS, row.len()),
-                OutOfDomainExtRow(row) => assert_eq!(NUM_EXT_COLUMNS, row.len()),
-                _ => (),
-            }
-        }
-
         let discriminant = vec![self.discriminant()];
         let encoding = match self {
             AuthenticationStructure(something) => something.encode(),

triton-vm/src/proof_stream.rs

@@ -1,5 +1,6 @@
 use anyhow::bail;
 use anyhow::Result;
+use arbitrary::Arbitrary;
 use twenty_first::shared_math::b_field_element::BFieldElement;
 use twenty_first::shared_math::b_field_element::BFIELD_ONE;
 use twenty_first::shared_math::b_field_element::BFIELD_ZERO;
@@ -11,7 +12,7 @@ use twenty_first::util_types::algebraic_hasher::AlgebraicHasher;
 use crate::proof::Proof;
 use crate::proof_item::ProofItem;
 
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Arbitrary)]
 pub struct ProofStream<H>
 where
     H: AlgebraicHasher,

triton-vm/src/stark.rs

@@ -3,6 +3,8 @@ use std::ops::Mul;
 
 use anyhow::bail;
 use anyhow::Result;
+use arbitrary::Arbitrary;
+use arbitrary::Unstructured;
 use itertools::izip;
 use itertools::Itertools;
 use ndarray::prelude::*;
@@ -125,6 +127,14 @@ impl Default for StarkParameters {
     }
 }
 
+impl<'a> Arbitrary<'a> for StarkParameters {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let security_level = u.int_in_range(1..=640)?;
+        let log_2_of_fri_expansion_factor = u.int_in_range(1..=8)?;
+        Ok(Self::new(security_level, log_2_of_fri_expansion_factor))
+    }
+}
+
 pub struct Stark {}
 
 impl Stark {
@@ -1095,6 +1105,8 @@ impl Stark {
 pub(crate) mod triton_stark_tests {
     use itertools::izip;
     use num_traits::Zero;
+    use proptest::prelude::*;
+    use proptest_arbitrary_interop::arb;
     use rand::prelude::ThreadRng;
     use rand::thread_rng;
     use rand::Rng;
@@ -1902,6 +1914,17 @@ pub(crate) mod triton_stark_tests {
         println!("{report}");
     }
 
+    proptest! {
+        #[test]
+        fn verifying_arbitrary_proof_does_not_panic(
+            parameters in arb::<StarkParameters>(),
+            claim in arb::<Claim>(),
+            proof in arb::<Proof>(),
+        ) {
+            let _ = Stark::verify(&parameters, &claim, &proof, &mut None);
+        }
+    }
+
     #[test]
     #[ignore = "stress test"]
     fn prove_fib_successively_larger() {