Zq/unfix pcs poly field

bin/src/dev_setup.rs

@@ -45,7 +45,10 @@ fn main() {
     }
 }
 
-fn proof_gen<C: GKREngine>() {
+fn proof_gen<C: GKREngine>()
+where
+    C::FieldConfig: FieldEngine<SimdCircuitField = C::PCSPolyField>,
+{
     let mpi_config = MPIConfig::prover_new();
 
     // load circuit
@@ -81,7 +84,7 @@ fn proof_gen<C: GKREngine>() {
     circuit.evaluate();
 
     let (pcs_params, pcs_proving_key, pcs_verification_key, pcs_scratch) =
-        expander_pcs_init_testing_only::<C::FieldConfig, C::PCSConfig>(
+        expander_pcs_init_testing_only::<C::FieldConfig, C::PCSPolyField, C::PCSConfig>(
             circuit.log_input_size(),
             &mpi_config,
         );

bin/src/executor.rs

@@ -124,13 +124,16 @@ pub fn prove<Cfg: GKREngine>(
 ) -> (
     <<Cfg as GKREngine>::FieldConfig as FieldEngine>::ChallengeField,
     Proof,
-) {
+)
+where
+    Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+{
     let mut prover = Prover::<Cfg>::new(mpi_config.clone());
     prover.prepare_mem(circuit);
 
     // TODO: Read PCS setup from files
     let (pcs_params, pcs_proving_key, _, mut pcs_scratch) =
-        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSConfig>(
+        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSPolyField, Cfg::PCSConfig>(
             circuit.log_input_size(),
             &mpi_config,
         );
@@ -148,6 +151,7 @@ pub fn verify<Cfg: GKREngine>(
     // TODO: Read PCS setup from files
     let (pcs_params, _, pcs_verification_key, _) = expander_pcs_init_testing_only::<
         Cfg::FieldConfig,
+        Cfg::PCSPolyField,
         Cfg::PCSConfig,
     >(circuit.log_input_size(), &mpi_config);
     let verifier = Verifier::<Cfg>::new(mpi_config);
@@ -165,7 +169,9 @@ pub fn verify<Cfg: GKREngine>(
 pub async fn run_command<Cfg: GKREngine + 'static>(
     command: &ExpanderExecArgs,
     mpi_config: &MPIConfig,
-) {
+) where
+    Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+{
     let subcommands = command.subcommands.clone();
 
     match subcommands {
@@ -263,7 +269,7 @@ pub async fn run_command<Cfg: GKREngine + 'static>(
 
             // TODO: Read PCS setup from files
             let (pcs_params, pcs_proving_key, pcs_verification_key, pcs_scratch) =
-                expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSConfig>(
+                expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSPolyField, Cfg::PCSConfig>(
                     circuit.log_input_size(),
                     &prover.mpi_config,
                 );

bin/src/main.rs

@@ -127,8 +127,9 @@ fn main() {
 
 fn run_benchmark<'a, Cfg: GKREngine>(args: &'a Args, mpi_config: MPIConfig)
 where
-    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::ScratchPad: 'a,
-    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::ScratchPad: 'static,
+    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::ScratchPad: 'a,
+    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::ScratchPad: 'static,
+    Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
 {
     let partial_proof_cnts = (0..args.threads)
         .map(|_| Arc::new(Mutex::new(0)))
@@ -223,7 +224,7 @@ where
     println!("Circuit loaded!");
 
     let (pcs_params, pcs_proving_key, _pcs_verification_key, pcs_scratch) =
-        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSConfig>(
+        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSPolyField, Cfg::PCSConfig>(
             circuit_template.log_input_size(),
             &mpi_config,
         );

bin/src/main_mpi.rs

@@ -117,7 +117,10 @@ fn main() {
     MPIConfig::finalize();
 }
 
-fn run_benchmark<Cfg: GKREngine>(args: &Args, mpi_config: MPIConfig) {
+fn run_benchmark<Cfg: GKREngine>(args: &Args, mpi_config: MPIConfig)
+where
+    Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+{
     let pack_size = <Cfg::FieldConfig as FieldEngine>::get_field_pack_size();
 
     // load circuit
@@ -196,7 +199,7 @@ fn run_benchmark<Cfg: GKREngine>(args: &Args, mpi_config: MPIConfig) {
     prover.prepare_mem(&circuit);
 
     let (pcs_params, pcs_proving_key, _pcs_verification_key, mut pcs_scratch) =
-        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSConfig>(
+        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSPolyField, Cfg::PCSConfig>(
             circuit.log_input_size(),
             &mpi_config,
         );

circuit/src/layered/circuit.rs

@@ -385,7 +385,7 @@ impl<C: FieldEngine> Circuit<C> {
         // If there will be two claims for the input
         // Introduce an extra relay layer before the input layer
         if !self.layers[0].structure_info.skip_sumcheck_phase_two {
-            match <Cfg::PCSConfig as ExpanderPCS<C>>::PCS_TYPE {
+            match <Cfg::PCSConfig as ExpanderPCS<C, _>>::PCS_TYPE {
                 // Raw PCS costs nothing in opening, so no need to add relay layer
                 // But we can probably add it in the future for verifier's convenience
                 PolynomialCommitmentType::Raw => (),

gkr/benches/gkr_hashes.rs

@@ -20,10 +20,12 @@ use transcript::BytesHashTranscript;
 fn prover_run<Cfg: GKREngine>(
     mpi_config: &MPIConfig,
     circuit: &mut Circuit<Cfg::FieldConfig>,
-    pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-    pcs_proving_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::PKey,
-    pcs_scratch: &mut <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::ScratchPad,
-) {
+    pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+    pcs_proving_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::SRS as StructuredReferenceString>::PKey,
+    pcs_scratch: &mut <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::ScratchPad,
+) where
+    Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+{
     let mut prover = Prover::<Cfg>::new(mpi_config.clone());
     prover.prepare_mem(circuit);
     prover.prove(circuit, pcs_params, pcs_proving_key, pcs_scratch);
@@ -35,10 +37,10 @@ fn benchmark_setup<Cfg: GKREngine>(
 ) -> (
     MPIConfig,
     Circuit<Cfg::FieldConfig>,
-    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-    <<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::PKey,
-    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::ScratchPad,
-) {
+    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+    <<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::SRS as StructuredReferenceString>::PKey,
+    <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::ScratchPad,
+){
     let mpi_config = MPIConfig::prover_new();
     let mut circuit =
         Circuit::<Cfg::FieldConfig>::single_thread_prover_load_circuit::<Cfg>(circuit_file);
@@ -50,7 +52,7 @@ fn benchmark_setup<Cfg: GKREngine>(
     }
 
     let (pcs_params, pcs_proving_key, _pcs_verification_key, pcs_scratch) =
-        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSConfig>(
+        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSPolyField, Cfg::PCSConfig>(
             circuit.log_input_size(),
             &mpi_config,
         );

gkr/src/prover/snark.rs

@@ -84,10 +84,13 @@ impl<Cfg: GKREngine> Prover<Cfg> {
     pub fn prove(
         &mut self,
         c: &mut Circuit<Cfg::FieldConfig>,
-        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-        pcs_proving_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::PKey,
-        pcs_scratch: &mut <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::ScratchPad,
-    ) -> (<Cfg::FieldConfig as FieldEngine>::ChallengeField, Proof) {
+        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+        pcs_proving_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::SRS as StructuredReferenceString>::PKey,
+        pcs_scratch: &mut <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::ScratchPad,
+    ) -> (<Cfg::FieldConfig as FieldEngine>::ChallengeField, Proof)
+    where
+        Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+    {
         let proving_timer = Timer::new("prover", self.mpi_config.is_root());
         let mut transcript = Cfg::TranscriptConfig::new();
 
@@ -195,11 +198,13 @@ impl<Cfg: GKREngine> Prover<Cfg> {
         &self,
         inputs: &mut MutRefMultiLinearPoly<<Cfg::FieldConfig as FieldEngine>::SimdCircuitField>,
         open_at: &mut ExpanderSingleVarChallenge<Cfg::FieldConfig>,
-        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-        pcs_proving_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::PKey,
-        pcs_scratch: &mut <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::ScratchPad,
+        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+        pcs_proving_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::SRS as StructuredReferenceString>::PKey,
+        pcs_scratch: &mut <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::ScratchPad,
         transcript: &mut impl Transcript,
-    ) {
+    ) where
+        Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+    {
         let original_input_vars = inputs.num_vars();
 
         let minimum_vars_for_pcs: usize = pcs_params.num_vars();

gkr/src/tests/gkr_correctness.rs

@@ -163,7 +163,10 @@ fn test_gkr_correctness() {
 }
 
 #[allow(unreachable_patterns)]
-fn test_gkr_correctness_helper<Cfg: GKREngine>(write_proof_to: Option<&str>) {
+fn test_gkr_correctness_helper<Cfg: GKREngine>(write_proof_to: Option<&str>)
+where
+    Cfg::FieldConfig: FieldEngine<SimdCircuitField = Cfg::PCSPolyField>,
+{
     let mpi_config = MPIConfig::prover_new();
 
     root_println!(mpi_config, "============== start ===============");
@@ -226,7 +229,7 @@ fn test_gkr_correctness_helper<Cfg: GKREngine>(write_proof_to: Option<&str>) {
     prover.prepare_mem(&circuit);
 
     let (pcs_params, pcs_proving_key, pcs_verification_key, mut pcs_scratch) =
-        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSConfig>(
+        expander_pcs_init_testing_only::<Cfg::FieldConfig, Cfg::PCSPolyField, Cfg::PCSConfig>(
             circuit.log_input_size(),
             &mpi_config,
         );

gkr/src/verifier/snark.rs

@@ -48,10 +48,10 @@ impl<Cfg: GKREngine> Verifier<Cfg> {
         circuit: &mut Circuit<Cfg::FieldConfig>,
         transcript: &mut Cfg::TranscriptConfig,
         proving_time_mpi_size: usize,
-    ) -> <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Commitment {
+    ) -> <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Commitment {
         let timer = Timer::new("pre_gkr", true);
         let commitment =
-            <<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Commitment as ExpSerde>::deserialize_from(
+            <<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Commitment as ExpSerde>::deserialize_from(
                 &mut proof_reader,
             )
             .unwrap();
@@ -258,9 +258,12 @@ impl<Cfg: GKREngine> Verifier<Cfg> {
     #[allow(clippy::type_complexity)]
     pub(crate) fn post_gkr(
         &self,
-        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::VKey,
-        commitment: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Commitment,
+        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<
+            Cfg::FieldConfig,
+            Cfg::PCSPolyField,
+        >>::SRS as StructuredReferenceString>::VKey,
+        commitment: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Commitment,
         challenge_x: &mut ExpanderSingleVarChallenge<Cfg::FieldConfig>,
         claim_x: &<Cfg::FieldConfig as FieldEngine>::ChallengeField,
         challenge_y: &mut Option<ExpanderSingleVarChallenge<Cfg::FieldConfig>>,
@@ -300,8 +303,11 @@ impl<Cfg: GKREngine> Verifier<Cfg> {
         circuit: &mut Circuit<Cfg::FieldConfig>,
         public_input: &[<Cfg::FieldConfig as FieldEngine>::SimdCircuitField],
         claimed_v: &<Cfg::FieldConfig as FieldEngine>::ChallengeField,
-        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::VKey,
+        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<
+            Cfg::FieldConfig,
+            Cfg::PCSPolyField,
+        >>::SRS as StructuredReferenceString>::VKey,
         proof: &Proof,
     ) -> bool {
         let timer = Timer::new("snark verify", true);
@@ -343,8 +349,11 @@ impl<Cfg: GKREngine> Verifier<Cfg> {
         circuit: &mut Circuit<Cfg::FieldConfig>,
         public_input: &[<Cfg::FieldConfig as FieldEngine>::SimdCircuitField],
         claimed_v: &<Cfg::FieldConfig as FieldEngine>::ChallengeField,
-        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::VKey,
+        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<
+            Cfg::FieldConfig,
+            Cfg::PCSPolyField,
+        >>::SRS as StructuredReferenceString>::VKey,
         proof: &Proof,
     ) -> bool {
         let timer = Timer::new("snark verify", true);
@@ -385,15 +394,18 @@ impl<Cfg: GKREngine> Verifier<Cfg> {
     #[allow(clippy::too_many_arguments)]
     fn get_pcs_opening_from_proof_and_verify(
         &self,
-        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Params,
-        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::SRS as StructuredReferenceString>::VKey,
-        commitment: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Commitment,
+        pcs_params: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Params,
+        pcs_verification_key: &<<Cfg::PCSConfig as ExpanderPCS<
+            Cfg::FieldConfig,
+            Cfg::PCSPolyField,
+        >>::SRS as StructuredReferenceString>::VKey,
+        commitment: &<Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Commitment,
         open_at: &mut ExpanderSingleVarChallenge<Cfg::FieldConfig>,
         v: &<Cfg::FieldConfig as FieldEngine>::ChallengeField,
         transcript: &mut impl Transcript,
         proof_reader: impl Read,
     ) -> bool {
-        let opening = <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig>>::Opening::deserialize_from(
+        let opening = <Cfg::PCSConfig as ExpanderPCS<Cfg::FieldConfig, Cfg::PCSPolyField>>::Opening::deserialize_from(
             proof_reader,
         )
         .unwrap();

gkr_engine/src/lib.rs

@@ -12,6 +12,7 @@
 //! - A Config is a struct that implements the Engine trait and contains the parameters for the GKR
 //!   protocol
 #![allow(clippy::manual_div_ceil)]
+#![feature(associated_type_defaults)]
 
 mod errors;
 mod field_engine;
@@ -20,6 +21,7 @@ mod poly_commit;
 mod scheme;
 mod transcript;
 
+use arith::Field;
 pub use errors::*;
 pub use field_engine::*;
 pub use mpi_engine::*;
@@ -71,7 +73,8 @@ pub trait GKREngine: Send + Sync {
     type TranscriptConfig: Transcript;
 
     /// Configuration for polynomial commitment scheme
-    type PCSConfig: ExpanderPCS<Self::FieldConfig>;
+    type PCSPolyField: Field = <<Self as GKREngine>::FieldConfig as FieldEngine>::SimdCircuitField;
+    type PCSConfig: ExpanderPCS<Self::FieldConfig, Self::PCSPolyField>;
 
     /// GKR scheme
     const SCHEME: GKRScheme;

gkr_engine/src/poly_commit/definition.rs

@@ -1,3 +1,4 @@
+use arith::Field;
 use polynomials::MultilinearExtension;
 use rand::RngCore;
 use serdes::ExpSerde;
@@ -25,7 +26,13 @@ impl PCSParams for usize {
     }
 }
 
-pub trait ExpanderPCS<F: FieldEngine> {
+/// This trait specifies the field used on Expander side.
+///   PolyField: the field of the coef of polynomial sent to PCS
+///   ChallengeField: the field of the challenge point, should be FieldEngine::ChallengeField
+///   EvalField: the field of the evaluation, in the current use case always be FieldEngine::Field
+/// since Polyfield has simd Note that it is not necessary that PolyField can be handled by PCS
+/// directly. PolyField should be bounded when implemented if necessary.
+pub trait ExpanderPCS<F: FieldEngine, PolyField: Field> {
     const NAME: &'static str;
 
     const PCS_TYPE: PolynomialCommitmentType;
@@ -65,7 +72,7 @@ pub trait ExpanderPCS<F: FieldEngine> {
         params: &Self::Params,
         mpi_engine: &impl MPIEngine,
         proving_key: &<Self::SRS as StructuredReferenceString>::PKey,
-        poly: &impl MultilinearExtension<F::SimdCircuitField>,
+        poly: &impl MultilinearExtension<PolyField>,
         scratch_pad: &mut Self::ScratchPad,
     ) -> Option<Self::Commitment>;
 
@@ -94,7 +101,7 @@ pub trait ExpanderPCS<F: FieldEngine> {
         params: &Self::Params,
         mpi_engine: &impl MPIEngine,
         proving_key: &<Self::SRS as StructuredReferenceString>::PKey,
-        poly: &impl MultilinearExtension<F::SimdCircuitField>,
+        poly: &impl MultilinearExtension<PolyField>,
         x: &ExpanderSingleVarChallenge<F>,
         transcript: &mut impl Transcript,
         scratch_pad: &Self::ScratchPad,

poly_commit/src/hyrax/expander_api.rs

@@ -18,11 +18,11 @@ use crate::{
     HyraxCommitment, HyraxOpening, HyraxPCS, PedersenParams,
 };
 
-impl<G, C> ExpanderPCS<G> for HyraxPCS<C>
+impl<G, C> ExpanderPCS<G, C::Scalar> for HyraxPCS<C>
 where
-    G: FieldEngine<ChallengeField = C::Scalar, SimdCircuitField = C::Scalar>,
+    G: FieldEngine<ChallengeField = C::Scalar>,
     C: CurveAffine + ExpSerde,
-    C::Scalar: ExtensionField + PrimeField,
+    C::Scalar: ExtensionField + PrimeField + From<G::SimdCircuitField>,
     C::ScalarExt: ExtensionField + PrimeField,
 {
     const NAME: &'static str = "HyraxPCSForExpanderGKR";
@@ -56,7 +56,7 @@ where
         _params: &Self::Params,
         mpi_engine: &impl MPIEngine,
         proving_key: &<Self::SRS as StructuredReferenceString>::PKey,
-        poly: &impl polynomials::MultilinearExtension<<G as FieldEngine>::SimdCircuitField>,
+        poly: &impl polynomials::MultilinearExtension<C::Scalar>,
         _scratch_pad: &mut Self::ScratchPad,
     ) -> Option<Self::Commitment> {
         let local_commit = hyrax_commit(proving_key, poly);
@@ -83,7 +83,7 @@ where
         _params: &Self::Params,
         mpi_engine: &impl MPIEngine,
         proving_key: &<Self::SRS as StructuredReferenceString>::PKey,
-        poly: &impl polynomials::MultilinearExtension<<G as FieldEngine>::SimdCircuitField>,
+        poly: &impl polynomials::MultilinearExtension<C::Scalar>,
         x: &ExpanderSingleVarChallenge<G>,
         _transcript: &mut impl Transcript,
         _scratch_pad: &Self::ScratchPad,