From 575e97fc81b48b5ad7bb5de797291307915f5e45 Mon Sep 17 00:00:00 2001 From: Jan Ferdinand Sauer Date: Tue, 8 Oct 2024 12:48:16 +0200 Subject: [PATCH] chore(deps): Update dependencies --- Cargo.toml | 2 +- triton-air/src/cross_table_argument.rs | 30 +++++++++++++++----------- triton-vm/src/arithmetic_domain.rs | 21 ++++++------------ triton-vm/src/fri.rs | 4 +++- triton-vm/src/stark.rs | 13 ++++++----- triton-vm/src/table/master_table.rs | 22 +++++++++++-------- 6 files changed, 49 insertions(+), 43 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index bef6ab22..2fe5eee3 100644 --- a/Cargo.toml +++ b/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" diff --git a/triton-air/src/cross_table_argument.rs b/triton-air/src/cross_table_argument.rs index c3e17e8a..0e5c371e 100644 --- a/triton-air/src/cross_table_argument.rs +++ b/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,27 +225,29 @@ mod tests { fn permutation_argument_is_identical_to_evaluating_zerofier_polynomial( #[strategy(arb())] roots: Vec, #[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, - #[strategy(arb())] challenge: BFieldElement, + #[strategy(arb())] + #[filter(!#polynomial.is_zero())] + polynomial: Polynomial, + #[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); } @@ -252,15 +255,16 @@ mod tests { #[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, #[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); } } diff --git a/triton-vm/src/arithmetic_domain.rs b/triton-vm/src/arithmetic_domain.rs index 81bcadfc..2c155264 100644 --- a/triton-vm/src/arithmetic_domain.rs +++ b/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::::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]); } } } diff --git a/triton-vm/src/fri.rs b/triton-vm/src/fri.rs index 681c7d16..e3a110ff 100644 --- a/triton-vm/src/fri.rs +++ b/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); diff --git a/triton-vm/src/stark.rs b/triton-vm/src/stark.rs index fd8ddabe..730c0f16 100644 --- a/triton-vm/src/stark.rs +++ b/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( @@ -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::(); - 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() diff --git a/triton-vm/src/table/master_table.rs b/triton-vm/src/table/master_table.rs index 5d33f4e6..ca3304ba 100644 --- a/triton-vm/src/table/master_table.rs +++ b/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::>().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::()); 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`." ); } }