refactor(test): also test transition constraints on extension table

triton-vm/src/stark.rs

@@ -1122,7 +1122,6 @@ pub(crate) mod tests {
     use crate::instruction::AnInstruction;
     use crate::instruction::Instruction;
     use crate::op_stack::OpStackElement;
-    use crate::program::Program;
     use crate::shared_tests::*;
     use crate::table::cascade_table;
     use crate::table::cascade_table::ExtCascadeTable;
@@ -1167,16 +1166,21 @@ pub(crate) mod tests {
     use crate::table::u32_table::ExtU32Table;
     use crate::triton_program;
     use crate::vm::tests::*;
-    use crate::NonDeterminism;
     use crate::PublicInput;
 
     use super::*;
 
     pub(crate) fn master_base_table_for_low_security_level(
-        program: &Program,
-        public_input: PublicInput,
-        non_determinism: NonDeterminism<BFieldElement>,
+        program_and_input: ProgramAndInput,
     ) -> (StarkParameters, Claim, MasterBaseTable) {
+        let ProgramAndInput {
+            program,
+            public_input,
+            non_determinism,
+        } = program_and_input;
+        let public_input: PublicInput = public_input.into();
+        let non_determinism = (&non_determinism).into();
+
         let (aet, stdout) = program
             .trace_execution(public_input.clone(), non_determinism)
             .unwrap();
@@ -1188,9 +1192,7 @@ pub(crate) mod tests {
     }
 
     pub(crate) fn master_tables_for_low_security_level(
-        program: &Program,
-        public_input: PublicInput,
-        non_determinism: NonDeterminism<BFieldElement>,
+        program_and_input: ProgramAndInput,
     ) -> (
         StarkParameters,
         Claim,
@@ -1199,19 +1201,19 @@ pub(crate) mod tests {
         Challenges,
     ) {
         let (parameters, claim, mut master_base_table) =
-            master_base_table_for_low_security_level(program, public_input, non_determinism);
+            master_base_table_for_low_security_level(program_and_input);
 
-        let dummy_challenges = Challenges::placeholder(Some(&claim));
+        let challenges = Challenges::deterministic_placeholder(Some(&claim));
         master_base_table.pad();
         let master_ext_table =
-            master_base_table.extend(&dummy_challenges, parameters.num_randomizer_polynomials);
+            master_base_table.extend(&challenges, parameters.num_randomizer_polynomials);
 
         (
             parameters,
             claim,
             master_base_table,
             master_ext_table,
-            dummy_challenges,
+            challenges,
         )
     }
 
@@ -1228,7 +1230,7 @@ pub(crate) mod tests {
             halt
         );
         let (_, _, master_base_table) =
-            master_base_table_for_low_security_level(&program, [].into(), [].into());
+            master_base_table_for_low_security_level(ProgramAndInput::without_input(program));
 
         println!();
         println!("Processor Table:");
@@ -1306,7 +1308,7 @@ pub(crate) mod tests {
             halt
         };
         let (_, _, master_base_table) =
-            master_base_table_for_low_security_level(&program, [].into(), [].into());
+            master_base_table_for_low_security_level(ProgramAndInput::without_input(program));
 
         println!();
         println!("Processor Table:");
@@ -1416,9 +1418,10 @@ pub(crate) mod tests {
         let read_nop_program = triton_program!(
             read_io 3 nop nop write_io push 17 write_io halt
         );
-        let public_input = vec![3, 5, 7].into();
+        let mut program_and_input = ProgramAndInput::without_input(read_nop_program);
+        program_and_input.public_input = vec![3, 5, 7];
         let (_, claim, _, master_ext_table, all_challenges) =
-            master_tables_for_low_security_level(&read_nop_program, public_input, [].into());
+            master_tables_for_low_security_level(program_and_input);
 
         let processor_table = master_ext_table.table(ProcessorTable);
         let processor_table_last_row = processor_table.slice(s![-1, ..]);
@@ -1452,14 +1455,10 @@ pub(crate) mod tests {
             .map(|c| c.consume())
             .collect_vec();
 
-        for (code_idx, code_with_input) in code_collection.into_iter().enumerate() {
+        for (code_idx, program_and_input) in code_collection.into_iter().enumerate() {
             println!("Checking Grand Cross-Table Argument for TASM snippet {code_idx}.");
             let (_, _, master_base_table, master_ext_table, challenges) =
-                master_tables_for_low_security_level(
-                    &code_with_input.program,
-                    code_with_input.public_input(),
-                    code_with_input.non_determinism(),
-                );
+                master_tables_for_low_security_level(program_and_input);
 
             let processor_table = master_ext_table.table(ProcessorTable);
             let processor_table_last_row = processor_table.slice(s![-1, ..]);
@@ -1696,13 +1695,9 @@ pub(crate) mod tests {
         }
     }
 
-    fn triton_table_constraints_evaluate_to_zero(source_code_and_input: ProgramAndInput) {
+    fn triton_table_constraints_evaluate_to_zero(program_and_input: ProgramAndInput) {
         let (_, _, master_base_table, master_ext_table, challenges) =
-            master_tables_for_low_security_level(
-                &source_code_and_input.program,
-                source_code_and_input.public_input(),
-                source_code_and_input.non_determinism(),
-            );
+            master_tables_for_low_security_level(program_and_input);
 
         assert_eq!(
             master_base_table.randomized_trace_table().nrows(),
@@ -1767,13 +1762,9 @@ pub(crate) mod tests {
         derived_constraints_evaluate_to_zero(test_program_for_halt());
     }
 
-    fn derived_constraints_evaluate_to_zero(source_code_and_input: ProgramAndInput) {
+    fn derived_constraints_evaluate_to_zero(program_and_input: ProgramAndInput) {
         let (_, _, master_base_table, master_ext_table, challenges) =
-            master_tables_for_low_security_level(
-                &source_code_and_input.program,
-                source_code_and_input.public_input(),
-                source_code_and_input.non_determinism(),
-            );
+            master_tables_for_low_security_level(program_and_input);
 
         let zero = XFieldElement::zero();
         let master_base_trace_table = master_base_table.trace_table();

triton-vm/src/table/challenges.rs

@@ -18,18 +18,17 @@
 //! table. Instead, the terminal of the Evaluation Argument is computed directly from the
 //! public input (respectively output) and the indeterminate.
 
-use arbitrary::Arbitrary;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::ops::Index;
 use std::ops::Range;
 use std::ops::RangeInclusive;
 
+use arbitrary::Arbitrary;
 use strum::Display;
 use strum::EnumCount;
 use strum::EnumIter;
 use twenty_first::shared_math::b_field_element::BFieldElement;
-use twenty_first::shared_math::other::random_elements;
 use twenty_first::shared_math::tip5::LOOKUP_TABLE;
 use twenty_first::shared_math::x_field_element::XFieldElement;
 
@@ -281,21 +280,6 @@ impl Challenges {
 
         Self { challenges }
     }
-
-    /// Stand-in challenges. Can be used in tests. For non-interactive STARKs, use the
-    /// Fiat-Shamir heuristic to derive the actual challenges.
-    ///
-    /// If no [`Claim`] is provided, a dummy claim is used.
-    pub fn placeholder(claim: Option<&Claim>) -> Self {
-        let dummy_claim = Claim {
-            program_digest: Default::default(),
-            input: vec![],
-            output: vec![],
-        };
-        let claim = claim.unwrap_or(&dummy_claim);
-        let stand_in_challenges = random_elements(Self::num_challenges_to_sample());
-        Self::new(stand_in_challenges, claim)
-    }
 }
 
 impl Index<ChallengeId> for Challenges {
@@ -323,9 +307,44 @@ impl Index<RangeInclusive<ChallengeId>> for Challenges {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
+    use itertools::Itertools;
+    use twenty_first::shared_math::b_field_element::BFIELD_ZERO;
+    use twenty_first::shared_math::other::random_elements;
+
     use super::*;
 
+    impl Challenges {
+        /// Stand-in challenges. Can be used in tests. For non-interactive STARKs, use the
+        /// Fiat-Shamir heuristic to derive the actual challenges.
+        ///
+        /// If no [`Claim`] is provided, a dummy claim is used.
+        pub fn placeholder(claim: Option<&Claim>) -> Self {
+            let dummy_claim = Claim {
+                program_digest: Default::default(),
+                input: vec![],
+                output: vec![],
+            };
+            let claim = claim.unwrap_or(&dummy_claim);
+            let stand_in_challenges = random_elements(Self::num_challenges_to_sample());
+            Self::new(stand_in_challenges, claim)
+        }
+
+        pub fn deterministic_placeholder(claim: Option<&Claim>) -> Self {
+            let dummy_claim = Claim {
+                program_digest: Default::default(),
+                input: vec![],
+                output: vec![],
+            };
+            let claim = claim.unwrap_or(&dummy_claim);
+            let stand_in_challenges = (1..=Self::num_challenges_to_sample())
+                .map(|i| BFieldElement::new(i as u64))
+                .map(|bfe| XFieldElement::new([BFIELD_ZERO, bfe, BFIELD_ZERO]))
+                .collect_vec();
+            Self::new(stand_in_challenges, claim)
+        }
+    }
+
     #[test]
     const fn compile_time_index_assertions() {
         // Terminal challenges are computed from public information, such as public input or

triton-vm/src/table/hash_table.rs

@@ -1862,6 +1862,7 @@ impl HashTable {
 
 #[cfg(test)]
 pub(crate) mod tests {
+    use crate::shared_tests::ProgramAndInput;
     use crate::stark::tests::master_tables_for_low_security_level;
     use crate::table::master_table::MasterTable;
     use crate::triton_asm;
@@ -1988,7 +1989,7 @@ pub(crate) mod tests {
         dbg!(aet.cascade_table_length());
 
         let (_, _, master_base_table, master_ext_table, challenges) =
-            master_tables_for_low_security_level(&program, [].into(), [].into());
+            master_tables_for_low_security_level(ProgramAndInput::without_input(program));
 
         let master_base_trace_table = master_base_table.trace_table();
         let master_ext_trace_table = master_ext_table.trace_table();

triton-vm/src/table/master_table.rs

@@ -1129,6 +1129,7 @@ mod tests {
     use twenty_first::shared_math::traits::FiniteField;
 
     use crate::arithmetic_domain::ArithmeticDomain;
+    use crate::shared_tests::ProgramAndInput;
     use crate::stark::tests::*;
     use crate::table::degree_lowering_table::DegreeLoweringBaseTableColumn;
     use crate::table::degree_lowering_table::DegreeLoweringExtTableColumn;
@@ -1141,8 +1142,8 @@ mod tests {
 
     #[test]
     fn base_table_width_is_correct() {
-        let (_, _, master_base_table) =
-            master_base_table_for_low_security_level(&triton_program!(halt), [].into(), [].into());
+        let program = ProgramAndInput::without_input(triton_program!(halt));
+        let (_, _, master_base_table) = master_base_table_for_low_security_level(program);
 
         assert_eq!(
             program_table::BASE_WIDTH,
@@ -1188,8 +1189,8 @@ mod tests {
 
     #[test]
     fn ext_table_width_is_correct() {
-        let (parameters, _, _, master_ext_table, _) =
-            master_tables_for_low_security_level(&triton_program!(halt), [].into(), [].into());
+        let program = ProgramAndInput::without_input(triton_program!(halt));
+        let (parameters, _, _, master_ext_table, _) = master_tables_for_low_security_level(program);
 
         assert_eq!(
             program_table::EXT_WIDTH,