chore(deps): Update dependencies

Cargo.toml

@@ -85,7 +85,7 @@ strum = { version = "0.26", features = ["derive"] }
 syn = "2.0"
 test-strategy = "0.4.0"
 thiserror = "1.0"
-twenty-first = "0.42.0-alpha.10"
+twenty-first = "0.42.0-alpha.11"
 unicode-width = "0.2"
 divan = "0.1.14"
 

triton-air/src/cross_table_argument.rs

@@ -214,6 +214,7 @@ impl GrandCrossTableArg {
 
 #[cfg(test)]
 mod tests {
+    use num_traits::Zero;
     use proptest::prelude::*;
     use proptest_arbitrary_interop::arb;
     use test_strategy::proptest;
@@ -224,43 +225,46 @@ mod tests {
     fn permutation_argument_is_identical_to_evaluating_zerofier_polynomial(
         #[strategy(arb())] roots: Vec<BFieldElement>,
         #[strategy(arb())] initial: XFieldElement,
-        #[strategy(arb())] challenge: BFieldElement,
+        #[strategy(arb())] challenge: XFieldElement,
     ) {
-        let poly_evaluation = initial * Polynomial::zerofier(&roots).evaluate(challenge);
-        let perm_arg_terminal = PermArg::compute_terminal(&roots, initial, challenge.lift());
+        let poly_evaluation =
+            initial * Polynomial::zerofier(&roots).evaluate::<_, XFieldElement>(challenge);
+        let perm_arg_terminal = PermArg::compute_terminal(&roots, initial, challenge);
         prop_assert_eq!(poly_evaluation, perm_arg_terminal);
     }
 
     #[proptest]
     fn evaluation_argument_is_identical_to_evaluating_polynomial(
-        #[strategy(arb())] polynomial: Polynomial<BFieldElement>,
-        #[strategy(arb())] challenge: BFieldElement,
+        #[strategy(arb())]
+        #[filter(!#polynomial.is_zero())]
+        polynomial: Polynomial<BFieldElement>,
+        #[strategy(arb())] challenge: XFieldElement,
     ) {
-        let poly_evaluation = polynomial.evaluate(challenge).lift();
+        let poly_evaluation: XFieldElement = polynomial.evaluate(challenge);
 
         let mut polynomial = polynomial;
         polynomial.normalize(); // remove leading zeros
-        let initial = polynomial.coefficients.pop();
-        let initial = initial.ok_or(TestCaseError::Reject("polynomial must be non-zero".into()))?;
+        let initial = polynomial.coefficients.pop().unwrap();
         polynomial.coefficients.reverse();
         let eval_arg_terminal =
-            EvalArg::compute_terminal(&polynomial.coefficients, initial.lift(), challenge.lift());
+            EvalArg::compute_terminal(&polynomial.coefficients, initial.lift(), challenge);
 
         prop_assert_eq!(poly_evaluation, eval_arg_terminal);
     }
 
     #[proptest]
     fn lookup_argument_is_identical_to_inverse_of_evaluation_of_zerofier_polynomial(
         #[strategy(arb())]
-        #[filter(#roots.iter().all(|&r| r != #challenge))]
+        #[filter(#roots.iter().all(|r| r.lift() != #challenge))]
         roots: Vec<BFieldElement>,
         #[strategy(arb())] initial: XFieldElement,
-        #[strategy(arb())] challenge: BFieldElement,
+        #[strategy(arb())] challenge: XFieldElement,
     ) {
         let polynomial = Polynomial::zerofier(&roots);
         let derivative = polynomial.formal_derivative();
-        let poly_evaluation = derivative.evaluate(challenge) / polynomial.evaluate(challenge);
-        let lookup_arg_terminal = LookupArg::compute_terminal(&roots, initial, challenge.lift());
+        let poly_evaluation = derivative.evaluate::<_, XFieldElement>(challenge)
+            / polynomial.evaluate::<_, XFieldElement>(challenge);
+        let lookup_arg_terminal = LookupArg::compute_terminal(&roots, initial, challenge);
         prop_assert_eq!(initial + poly_evaluation, lookup_arg_terminal);
     }
 }

triton-vm/src/arithmetic_domain.rs

@@ -209,8 +209,8 @@ mod tests {
 
     #[test]
     fn domain_values() {
-        let x_cubed_coefficients = bfe_vec![0, 0, 0, 1];
-        let poly = Polynomial::new(x_cubed_coefficients.clone());
+        let poly = Polynomial::<BFieldElement>::x_to_the(3);
+        let x_cubed_coefficients = poly.coefficients.clone();
 
         for order in [4, 8, 32] {
             let generator = BFieldElement::primitive_root_of_unity(order).unwrap();
@@ -226,14 +226,8 @@ mod tests {
             let actual_b_values_2 = (0..order as u32)
                 .map(|i| b_domain.domain_value(i))
                 .collect_vec();
-            assert_eq!(
-                expected_b_values, actual_b_values_1,
-                "domain_values() generates the arithmetic domain's BFieldElement values"
-            );
-            assert_eq!(
-                expected_b_values, actual_b_values_2,
-                "domain_value() generates the given domain BFieldElement value"
-            );
+            assert_eq!(expected_b_values, actual_b_values_1);
+            assert_eq!(expected_b_values, actual_b_values_2);
 
             let values = b_domain.evaluate(&poly);
             assert_ne!(values, x_cubed_coefficients);
@@ -243,10 +237,9 @@ mod tests {
 
             // Verify that batch-evaluated values match a manual evaluation
             for i in 0..order {
-                assert_eq!(
-                    poly.evaluate(b_domain.domain_value(i as u32)),
-                    values[i as usize]
-                );
+                let indeterminate = b_domain.domain_value(i as u32);
+                let evaluation: BFieldElement = poly.evaluate(indeterminate);
+                assert_eq!(evaluation, values[i as usize]);
             }
         }
     }

triton-vm/src/fri.rs

@@ -479,7 +479,9 @@ impl<'stream> FriVerifier<'stream> {
         }
 
         let indeterminate = self.proof_stream.sample_scalars(1)[0];
-        let horner_evaluation = self.last_round_polynomial.evaluate(indeterminate);
+        let horner_evaluation = self
+            .last_round_polynomial
+            .evaluate_in_same_field(indeterminate);
         let barycentric_evaluation = barycentric_evaluate(&self.last_round_codeword, indeterminate);
         if horner_evaluation != barycentric_evaluation {
             return Err(FriValidationError::LastRoundPolynomialEvaluationMismatch);

triton-vm/src/stark.rs

@@ -2514,11 +2514,11 @@ pub(crate) mod tests {
     ) {
         let x_pow_n = x.mod_pow_u32(N as u32);
         let evaluate_segment = |(segment_idx, segment): (_, &Polynomial<_>)| {
-            segment.evaluate(x_pow_n) * x.mod_pow_u32(segment_idx as u32)
+            segment.evaluate::<_, FF>(x_pow_n) * x.mod_pow_u32(segment_idx as u32)
         };
         let evaluated_segments = segments.iter().enumerate().map(evaluate_segment);
         let sum_of_evaluated_segments = evaluated_segments.fold(FF::zero(), |acc, x| acc + x);
-        assert!(f.evaluate(x) == sum_of_evaluated_segments);
+        assert!(f.evaluate::<_, FF>(x) == sum_of_evaluated_segments);
     }
 
     fn assert_segments_degrees_are_small_enough<const N: usize, FF: FiniteField>(
@@ -2739,13 +2739,16 @@ pub(crate) mod tests {
 
         let segments_evaluated = (0..)
             .zip(&segment_polynomials)
-            .map(|(segment_index, segment_polynomial)| {
+            .map(|(segment_index, segment_polynomial)| -> XFieldElement {
                 let point_to_the_seg_idx = random_point.mod_pow_u32(segment_index);
                 let point_to_the_num_seg = random_point.mod_pow_u32(num_segments as u32);
-                point_to_the_seg_idx * segment_polynomial.evaluate(point_to_the_num_seg)
+                let segment_in_point_to_the_num_seg =
+                    segment_polynomial.evaluate_in_same_field(point_to_the_num_seg);
+                point_to_the_seg_idx * segment_in_point_to_the_num_seg
             })
             .sum::<XFieldElement>();
-        prop_assert_eq!(segments_evaluated, polynomial.evaluate(random_point));
+        let evaluation_in_random_point = polynomial.evaluate_in_same_field(random_point);
+        prop_assert_eq!(segments_evaluated, evaluation_in_random_point);
 
         let segments_codewords = segment_polynomials
             .iter()

triton-vm/src/table/master_table.rs

@@ -1335,7 +1335,7 @@ mod tests {
         assert_eq!(big_order as usize, initial_zerofier_inv.len());
         assert_eq!(1, initial_zerofier_poly.degree());
         assert!(initial_zerofier_poly
-            .evaluate(small_domain.domain_value(0))
+            .evaluate_in_same_field(small_domain.domain_value(0))
             .is_zero());
 
         let consistency_zerofier_inv =
@@ -1346,7 +1346,9 @@ mod tests {
         assert_eq!(big_order as usize, consistency_zerofier_inv.len());
         assert_eq!(small_order as isize, consistency_zerofier_poly.degree());
         for val in small_domain.domain_values() {
-            assert!(consistency_zerofier_poly.evaluate(val).is_zero());
+            assert!(consistency_zerofier_poly
+                .evaluate_in_same_field(val)
+                .is_zero());
         }
 
         let transition_zerofier_inv =
@@ -1360,7 +1362,9 @@ mod tests {
             .iter()
             .take(small_order as usize - 1)
         {
-            assert!(transition_zerofier_poly.evaluate(val).is_zero());
+            assert!(transition_zerofier_poly
+                .evaluate_in_same_field(val)
+                .is_zero());
         }
 
         let terminal_zerofier_inv = terminal_quotient_zerofier_inverse(small_domain, big_domain);
@@ -1369,7 +1373,7 @@ mod tests {
         assert_eq!(big_order as usize, terminal_zerofier_inv.len());
         assert_eq!(1, terminal_zerofier_poly.degree());
         assert!(terminal_zerofier_poly
-            .evaluate(small_domain.domain_value(small_order as u32 - 1))
+            .evaluate_in_same_field(small_domain.domain_value(small_order as u32 - 1))
             .is_zero());
     }
 
@@ -2081,11 +2085,11 @@ mod tests {
     /// constraints was intentional, this test should be updated.
     ///
     /// This test might fail in the course of CI for a pull request, if in the
-    /// mean time the constraints are modified on master. In this case, rebasing
+    /// meantime the constraints are modified on master. In this case, rebasing
     /// the topic branch on top of master is recommended.
     #[test]
     fn air_constraints_evaluators_have_not_changed() {
-        let mut rng = StdRng::seed_from_u64(3508729174085202315_u64);
+        let mut rng = StdRng::seed_from_u64(3508729174085202315);
 
         // pseudorandomly populate circuit inputs
         let main_row_current_base = Array1::from(rng.gen::<MainRow<BFieldElement>>().to_vec());
@@ -2159,7 +2163,7 @@ mod tests {
         let polynomial = Polynomial::new(coefficients);
 
         // evaluate polynomial in pseudorandom indeterminate
-        let value = polynomial.evaluate(rng.gen());
+        let value = polynomial.evaluate(rng.gen::<XFieldElement>());
         let expected = xfe!([
             3564660585377840245_u64,
             8403714483000428991_u64,
@@ -2168,8 +2172,8 @@ mod tests {
         assert_eq!(
             expected, value,
             "expected: {expected}\nobserved: {value}\n\
-        If there was an intentional change to the constraints, don't forget to \
-        update the value of `expected`."
+            If there was an intentional change to the constraints, don't forget to \
+            update the value of `expected`."
         );
     }
 }