refactor(jolt-field): Land Solinas field from akita-field in jolt-field

.github/workflows/rust.yml

@@ -45,6 +45,25 @@ jobs:
       - name: taplo fmt --check
         run: taplo fmt --check
 
+  field-stack:
+    name: Shared field feature matrix
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - name: Install nextest
+        uses: taiki-e/install-action@nextest
+      - name: Require one jolt-field identity (bootstrap akita-field pin allowed)
+        run: scripts/check-shared-field-identity.sh
+      - name: Check no backend
+        run: cargo check -p jolt-field --no-default-features
+      - name: Check BN254 backend
+        run: cargo check -p jolt-field --no-default-features --features bn254
+      - name: Test Solinas backend
+        run: cargo nextest run -p jolt-field --no-default-features --features solinas --cargo-quiet
+      - name: Check combined backends
+        run: cargo check -p jolt-field --no-default-features --features bn254,solinas
+
   clippy:
     runs-on: ubuntu-latest
     steps:

crates/jolt-akita/benches/akita_paths.rs

@@ -54,7 +54,7 @@ use jolt_akita::{
     AkitaScheme, AkitaSetupParams, AKITA_ONE_HOT_K256,
 };
 use jolt_dory::{DoryCommitment, DoryHint, DoryScheme};
-use jolt_field::{Field, Fr, FromPrimitiveInt};
+use jolt_field::{Fr, JoltField, Ring};
 use jolt_openings::{
     prove_packed_openings, BatchOpeningScheme, CommitmentScheme, EvaluationClaim,
     PackedOpeningProof, PackedProverGroup, PackedProverObject, PrefixPackedStatement,
@@ -233,23 +233,26 @@ fn criterion_filter_matches(group_name: &str) -> bool {
     })
 }
 
-fn field<F: FromPrimitiveInt>(value: u64) -> F {
+fn field<F: Ring>(value: u64) -> F {
     F::from_u64(value)
 }
 
-fn deterministic_dense_poly<F: Field>(num_vars: usize) -> Polynomial<F> {
+fn deterministic_dense_poly<F: JoltField>(num_vars: usize) -> Polynomial<F> {
     deterministic_dense_poly_with_offset(num_vars, 0)
 }
 
-fn deterministic_dense_poly_with_offset<F: Field>(num_vars: usize, offset: u64) -> Polynomial<F> {
+fn deterministic_dense_poly_with_offset<F: JoltField>(
+    num_vars: usize,
+    offset: u64,
+) -> Polynomial<F> {
     let len = 1usize << num_vars;
     let evals = (0..len)
         .map(|i| field::<F>(((i as u64 * 17 + offset * 19 + 5) % 31) + 1))
         .collect();
     Polynomial::new(evals)
 }
 
-fn deterministic_point<F: Field>(num_vars: usize) -> Vec<F> {
+fn deterministic_point<F: JoltField>(num_vars: usize) -> Vec<F> {
     (0..num_vars)
         .map(|i| field::<F>(((i as u64 * 7 + 11) % 97) + 2))
         .collect()
@@ -263,7 +266,7 @@ fn sparse_one_hot(num_vars: usize) -> OneHotPolynomial {
     OneHotPolynomial::new(AKITA_ONE_HOT_K256, indices)
 }
 
-fn materialize_sparse<F: Field>(poly: &OneHotPolynomial) -> Polynomial<F> {
+fn materialize_sparse<F: JoltField>(poly: &OneHotPolynomial) -> Polynomial<F> {
     let mut evals = vec![F::zero(); 1usize << poly.num_vars()];
     <OneHotPolynomial as MultilinearPoly<F>>::for_each_one(poly, &mut |index| {
         evals[index] = F::one();

crates/jolt-akita/tests/pathologies.rs

@@ -13,7 +13,7 @@ use jolt_akita::{
     AkitaBackendFlavor, AkitaBatchProof, AkitaCommitment, AkitaField, AkitaNativeBatchStatement,
     AkitaNativeBatching, AkitaScheme,
 };
-use jolt_field::Field;
+use jolt_field::JoltField;
 use jolt_openings::{
     BatchOpeningScheme, CommitmentScheme, OpeningsError, ZkBatchOpeningScheme, ZkOpeningScheme,
 };
@@ -24,7 +24,7 @@ use support::{batch_polynomials, f, layout, native_setup, polynomial, setup_for}
 
 type VerifierSetup = <AkitaScheme as CommitmentScheme>::VerifierSetup;
 
-fn require_jolt_field<F: Field>() {}
+fn require_jolt_field<F: JoltField>() {}
 
 #[test]
 fn akita_field_satisfies_jolt_field_bundle() {

crates/jolt-blindfold/src/assignment.rs

@@ -14,7 +14,7 @@
 //! forward pass over the constraint matrices solves them in emission order.
 //! Unconstrained slots are the layout's zero padding.
 
-use jolt_field::Field;
+use jolt_field::JoltField;
 use jolt_r1cs::SparseRow;
 use jolt_sumcheck::{CommittedSumcheckWitness, SumcheckDomain, SumcheckDomainSpec};
 use rand_core::RngCore;
@@ -31,7 +31,7 @@ pub struct AssignedBlindFoldWitness<F> {
     pub blindings: Vec<F>,
 }
 
-impl<F: Field, Com> BlindFoldProtocol<F, Com> {
+impl<F: JoltField, Com> BlindFoldProtocol<F, Com> {
     /// Assemble the witness rows and blinds for [`crate::prove`] from the
     /// per-stage committed sumcheck witnesses and domains (in protocol stage
     /// order) and the final-opening evaluation scalars/blinds (in
@@ -301,7 +301,7 @@ impl<F: Field, Com> BlindFoldProtocol<F, Com> {
     }
 }
 
-fn assign<F: Field>(
+fn assign<F: JoltField>(
     witness: &mut [Option<F>],
     index: usize,
     value: F,
@@ -321,7 +321,7 @@ fn assign<F: Field>(
 /// *after* its operands, so a single forward pass assigns each in turn; the
 /// equality constraints (round sums, claim bindings, final openings) have a
 /// zero C side and are skipped — they are checks, not definitions.
-fn solve_products<F: Field>(
+fn solve_products<F: JoltField>(
     a: &[SparseRow<F>],
     b: &[SparseRow<F>],
     c: &[SparseRow<F>],
@@ -357,7 +357,7 @@ fn solve_products<F: Field>(
     Ok(())
 }
 
-fn evaluate_sparse<F: Field>(row: &SparseRow<F>, witness: &[Option<F>]) -> Option<F> {
+fn evaluate_sparse<F: JoltField>(row: &SparseRow<F>, witness: &[Option<F>]) -> Option<F> {
     row.iter()
         .map(|&(index, coefficient)| {
             witness
@@ -369,7 +369,7 @@ fn evaluate_sparse<F: Field>(row: &SparseRow<F>, witness: &[Option<F>]) -> Optio
         .sum()
 }
 
-fn evaluate_at<F: Field>(coefficients: &[F], point: F) -> F {
+fn evaluate_at<F: JoltField>(coefficients: &[F], point: F) -> F {
     coefficients
         .iter()
         .rev()

crates/jolt-blindfold/src/builder.rs

@@ -1,5 +1,5 @@
 use jolt_claims::Expr;
-use jolt_field::Field;
+use jolt_field::JoltField;
 use jolt_sumcheck::{
     CommittedOutputClaims, CommittedSumcheckConsistency, SumcheckDomainSpec, SumcheckStatement,
 };
@@ -64,7 +64,7 @@ impl<F, O, Com, P, Ch> Default for BlindFoldProtocolBuilder<F, O, Com, P, Ch> {
 
 impl<F, O, Com, P, Ch> BlindFoldProtocolBuilder<F, O, Com, P, Ch>
 where
-    F: Field + Clone,
+    F: JoltField + Clone,
     O: Clone + PartialEq,
     Com: Clone,
     P: Clone + PartialEq,

crates/jolt-blindfold/src/error.rs

@@ -1,5 +1,5 @@
 use jolt_crypto::VectorOpeningError;
-use jolt_field::FieldCore;
+use jolt_field::JoltField;
 use jolt_r1cs::{ClaimLoweringError, ConstraintMatrixEvalError};
 use jolt_sumcheck::{SumcheckError, SumcheckR1csError};
 use thiserror::Error as ThisError;
@@ -85,7 +85,7 @@ pub enum RelaxedError {
 }
 
 #[derive(Debug, ThisError)]
-pub enum ProverError<F: FieldCore> {
+pub enum ProverError<F: JoltField> {
     #[error(transparent)]
     Relaxed(#[from] RelaxedError),
     #[error(transparent)]
@@ -153,7 +153,7 @@ pub enum ProverError<F: FieldCore> {
 }
 
 #[derive(Debug, ThisError)]
-pub enum VerificationError<F: FieldCore> {
+pub enum VerificationError<F: JoltField> {
     #[error("claims have {claim_stages} stages but proof has {proof_stages}")]
     StageCountMismatch {
         claim_stages: usize,

crates/jolt-blindfold/src/proof.rs

@@ -1,5 +1,5 @@
 use jolt_crypto::VectorCommitmentOpening;
-use jolt_field::Field;
+use jolt_field::JoltField;
 use jolt_sumcheck::CompressedSumcheckProof;
 use serde::{Deserialize, Serialize};
 
@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
     serialize = "F: Serialize, Com: Serialize",
     deserialize = "F: for<'a> Deserialize<'a>, Com: Deserialize<'de>"
 ))]
-pub struct BlindFoldProof<F: Field, Com> {
+pub struct BlindFoldProof<F: JoltField, Com> {
     pub auxiliary_row_commitments: Vec<Com>,
     pub random_round_commitments: Vec<Com>,
     pub random_output_claim_row_commitments: Vec<Com>,

crates/jolt-blindfold/src/protocol.rs

@@ -1,7 +1,7 @@
 use std::ops::Range;
 
 use jolt_crypto::HomomorphicCommitment;
-use jolt_field::Field;
+use jolt_field::JoltField;
 use jolt_r1cs::{ConstraintMatrices, R1csBuilder, Variable};
 use jolt_sumcheck::{CommittedOutputClaims, CommittedSumcheckConsistency};
 
@@ -11,7 +11,7 @@ use crate::{
 };
 
 #[derive(Clone, Debug)]
-pub struct BlindFoldProtocol<F: Field, Com> {
+pub struct BlindFoldProtocol<F: JoltField, Com> {
     pub sumcheck_consistency: Vec<CommittedSumcheckConsistency<F, Com>>,
     pub committed_output_claims: Vec<CommittedOutputClaims<Com>>,
     pub r1cs: ConstraintMatrices<F>,
@@ -60,7 +60,7 @@ pub struct FinalOpeningWitnessCoordinates {
 
 impl<F, Com> BlindFoldProtocol<F, Com>
 where
-    F: Field,
+    F: JoltField,
 {
     pub fn builder<O, P, Ch>() -> BlindFoldProtocolBuilder<F, O, Com, P, Ch> {
         BlindFoldProtocolBuilder::new()
@@ -69,7 +69,7 @@ where
 
 impl<F, Com> BlindFoldProtocol<F, Com>
 where
-    F: Field + Clone,
+    F: JoltField + Clone,
     Com: Clone,
 {
     pub(crate) fn from_parts<O, P, Ch>(
@@ -103,7 +103,7 @@ where
 
 impl<F, Com> BlindFoldProtocol<F, Com>
 where
-    F: Field,
+    F: JoltField,
     Com: Clone + HomomorphicCommitment<F>,
 {
     pub fn committed_relaxed_instance(
@@ -166,7 +166,7 @@ where
 
 impl<F, Com> BlindFoldProtocol<F, Com>
 where
-    F: Field,
+    F: JoltField,
 {
     pub fn validate_cross_term_error_rows(
         &self,
@@ -236,7 +236,7 @@ where
 
 impl<F, Com> BlindFoldProtocol<F, Com>
 where
-    F: Field,
+    F: JoltField,
     Com: Clone + HomomorphicCommitment<F>,
 {
     pub fn random_relaxed_instance(
@@ -310,7 +310,7 @@ where
 
 impl<F, O, Com, P, Ch> BlindFoldStatement<F, O, Com, P, Ch>
 where
-    F: Field + Clone,
+    F: JoltField + Clone,
     O: Clone + PartialEq,
     Com: Clone,
     P: Clone + PartialEq,
@@ -443,7 +443,7 @@ where
 }
 
 impl Layout {
-    fn dimensions<F: Field, Com>(
+    fn dimensions<F: JoltField, Com>(
         &self,
         r1cs: &ConstraintMatrices<F>,
         sumcheck_consistency: &[CommittedSumcheckConsistency<F, Com>],
@@ -563,7 +563,7 @@ fn pad_rows<F, Com>(
     name: &'static str,
 ) -> Result<(), RelaxedError>
 where
-    F: Field,
+    F: JoltField,
     Com: Clone + HomomorphicCommitment<F>,
 {
     if rows.len() > target_len {
@@ -613,7 +613,7 @@ mod tests {
     };
     use jolt_claims::{constant, opening, Expr};
     use jolt_crypto::{Bn254, Bn254G1, JoltGroup, Pedersen, PedersenSetup, VectorCommitment};
-    use jolt_field::{Fr, FromPrimitiveInt};
+    use jolt_field::{Fr, Ring};
     use jolt_sumcheck::{
         CommittedOutputClaims, CommittedRound, CommittedSumcheckProof, SumcheckDomainSpec,
         SumcheckError, SumcheckStatement,