feat(jolt-verifier): Refactor Akita verifier packing ownership and public API boundaries

crates/jolt-akita/src/scheme.rs

@@ -168,11 +168,11 @@
 }
 
 impl CommitmentScheme for AkitaScheme {
     type Field = AkitaField;
     type Proof = AkitaBatchProof;
     type ProverSetup = AkitaProverSetup;
     type VerifierSetup = AkitaVerifierSetup;
     type Polynomial = Polynomial<AkitaField>;
     type OpeningHint = AkitaProverHint;
     type SetupParams = AkitaSetupParams;
 
@@ -216,11 +216,11 @@
         clippy::panic,
         reason = "CommitmentScheme::commit cannot return native Akita commit errors"
     )]
     fn commit<P: MultilinearPoly<Self::Field> + ?Sized>(
         poly: &P,
         setup: &Self::ProverSetup,
     ) -> (Self::Output, Self::OpeningHint) {
         let polynomial = Polynomial::from(polynomial_evaluations(poly));
         Self::commit_group(setup, setup.default_layout_digest, &[polynomial])
             .unwrap_or_else(|err| panic!("Akita commit failed: {err}"))
     }
@@ -237,7 +237,7 @@
         hint: Option<Self::OpeningHint>,
         transcript: &mut impl Transcript<Challenge = Self::Field>,
     ) -> Self::Proof {
         let hint = hint.unwrap_or_else(|| Self::commit(poly, setup).1);
         let statement = singleton_statement(hint.commitment.clone(), point, eval);
         <Self as BatchOpeningScheme>::prove_batch(
             setup,
@@ -417,6 +417,71 @@
         .expect_err("changed direct commitment digest should reject");
     }
 
+    #[test]
+    fn sparse_native_polynomial_batch_opening_roundtrips_and_binds_commitment() {
+        let num_vars = 6;
+        let setup_params = AkitaSetupParams::new(num_vars, 1, [19; 32]);
+        let (prover_setup, verifier_setup) = AkitaScheme::setup(setup_params);
+        let unit_indices = [0, 3, 17];
+        let sparse = AkitaSparsePolynomial::from_jolt_unit_indices(num_vars, unit_indices)
+            .expect("sparse polynomial should build");
+        let (commitment, hint) =
+            AkitaScheme::commit_sparse_polynomial(&prover_setup, [23; 32], &sparse)
+                .expect("sparse commitment should build");
+        let mut dense = vec![AkitaField::zero(); 1 << num_vars];
+        for index in unit_indices {
+            dense[index] = AkitaField::one();
+        }
+        let point = (0..num_vars)
+            .map(|index| AkitaField::from_u64(index as u64 + 2))
+            .collect::<Vec<_>>();
+        let claim = Polynomial::new(dense).evaluate(&point);
+        let statement = BatchOpeningStatement {
+            logical_point: point.clone(),
+            pcs_point: point,
+            layout_digest: commitment.layout_digest,
+            claims: vec![BatchOpeningClaim {
+                id: (),
+                relation: (),
+                commitment: commitment.clone(),
+                claim,
+                view: PhysicalView::Direct,
+                scale: AkitaField::one(),
+            }],
+        };
+
+        let mut prover_transcript = RecordingTranscript::new(b"akita-sparse-native");
+        let proof = AkitaScheme::prove_sparse_batch(
+            &prover_setup,
+            &mut prover_transcript,
+            &statement,
+            &sparse,
+            hint,
+        )
+        .expect("sparse proof should prove");
+        assert_eq!(proof.commitment, commitment);
+
+        let mut verifier_transcript = RecordingTranscript::new(b"akita-sparse-native");
+        let _result = AkitaScheme::verify_batch(
+            &verifier_setup,
+            &mut verifier_transcript,
+            &statement,
+            &proof,
+        )
+        .expect("sparse proof should verify");
+
+        let mut tampered_proof = proof;
+        tampered_proof.commitment.layout_digest = [42; 32];
+        let mut verifier_transcript = RecordingTranscript::new(b"akita-sparse-native");
+        let _error = AkitaScheme::verify_batch(
+            &verifier_setup,
+            &mut verifier_transcript,
+            &statement,
+            &tampered_proof,
+        )
+        .expect_err("tampered proof commitment should reject");
+    }
+
     fn contains_subslice(haystack: &[u8], needle: &[u8]) -> bool {
         haystack
             .windows(needle.len())

crates/jolt-claims/src/lib.rs

@@ -1,4 +1,11 @@
 //! Shared claim and expression types for Jolt protocols.
+//!
+//! This crate owns protocol semantics: symbolic claim expressions, typed opening
+//! and challenge identifiers, relation metadata, and Jolt-specific formula
+//! builders. The lattice/Akita surface follows the same rule: `jolt-claims`
+//! names Jolt facts, logical view formulas, and validity requirements, while
+//! physical packing layouts and PCS transport remain in `jolt-openings`,
+//! `jolt-verifier`, and the backend adapter crates.
 
 mod claims;
 mod ops;

crates/jolt-claims/src/protocols/field_inline/formulas/lattice.rs

@@ -1,9 +1,7 @@
 use jolt_field::Field;
-use jolt_openings::{
-    PackingFamilyId, PackingValidityRequirement, PackingViewFormula, PackingViewTerm,
-};
+use jolt_openings::{PackingValidityRequirement, PackingViewFormula, PackingViewTerm};
 
-use crate::protocols::jolt::weighted_byte_decode_terms;
+use crate::protocols::jolt::{weighted_byte_decode_terms, JoltPackingFamilyId};
 
 pub fn field_rd_inc_lattice_view_formula<F: Field>(byte_width: usize) -> PackingViewFormula<F> {
     PackingViewFormula::linear_decoded(field_rd_inc_byte_terms(byte_width))
@@ -14,7 +12,7 @@ pub fn field_rd_inc_byte_terms<F: Field>(byte_width: usize) -> Vec<PackingViewTe
     let mut place = F::one();
     for index in 0..byte_width {
         terms.extend(weighted_byte_decode_terms(
-            PackingFamilyId::FieldRdIncByte { index },
+            JoltPackingFamilyId::FieldRdIncByte { index }.into(),
             [(0, place)],
         ));
         place *= F::from_u64(256);
@@ -26,7 +24,7 @@ pub fn field_rd_inc_validity_requirements(byte_width: usize) -> Vec<PackingValid
     (0..byte_width)
         .map(|index| {
             PackingValidityRequirement::exact_one_hot(
-                PackingFamilyId::FieldRdIncByte { index },
+                JoltPackingFamilyId::FieldRdIncByte { index }.into(),
                 1,
                 256,
             )
@@ -39,7 +37,7 @@ pub fn field_rd_inc_canonical_bytes_requirement(
     modulus: u128,
 ) -> PackingValidityRequirement {
     PackingValidityRequirement::field_element_canonical_bytes(
-        PackingFamilyId::FieldRdIncByte { index: 0 },
+        JoltPackingFamilyId::FieldRdIncByte { index: 0 }.into(),
         byte_width,
         modulus,
     )
@@ -58,7 +56,7 @@ mod tests {
         assert_eq!(terms[7].coefficient, Fr::from_u64(7));
         assert_eq!(
             terms[7].family,
-            PackingFamilyId::FieldRdIncByte { index: 0 }
+            JoltPackingFamilyId::FieldRdIncByte { index: 0 }.into()
         );
         assert_eq!(terms[7].limb, 0);
         assert_eq!(terms[7].symbol, 7);
@@ -67,7 +65,7 @@ mod tests {
         assert_eq!(second_byte.coefficient, Fr::from_u64(3 * 256));
         assert_eq!(
             second_byte.family,
-            PackingFamilyId::FieldRdIncByte { index: 1 }
+            JoltPackingFamilyId::FieldRdIncByte { index: 1 }.into()
         );
         assert_eq!(second_byte.limb, 0);
         assert_eq!(second_byte.symbol, 3);
@@ -79,12 +77,12 @@ mod tests {
             field_rd_inc_validity_requirements(2),
             vec![
                 PackingValidityRequirement::exact_one_hot(
-                    PackingFamilyId::FieldRdIncByte { index: 0 },
+                    JoltPackingFamilyId::FieldRdIncByte { index: 0 }.into(),
                     1,
                     256,
                 ),
                 PackingValidityRequirement::exact_one_hot(
-                    PackingFamilyId::FieldRdIncByte { index: 1 },
+                    JoltPackingFamilyId::FieldRdIncByte { index: 1 }.into(),
                     1,
                     256,
                 ),
@@ -97,7 +95,7 @@ mod tests {
         assert_eq!(
             field_rd_inc_canonical_bytes_requirement(2, 257),
             PackingValidityRequirement::field_element_canonical_bytes(
-                PackingFamilyId::FieldRdIncByte { index: 0 },
+                JoltPackingFamilyId::FieldRdIncByte { index: 0 }.into(),
                 2,
                 257,
             )